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

package/dist/analyzer/typeEvaluator/typeVarHandling.js

@@ -0,0 +1,756 @@
+"use strict";
+/*
+ * typeVarHandling.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * typeVarHandling implementation, using evaluator-owned dependencies and state.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTypeVarHandling = createTypeVarHandling;
+const debug_1 = require("../../common/debug");
+const diagnosticRules_1 = require("../../common/diagnosticRules");
+const pythonVersion_1 = require("../../common/pythonVersion");
+const uri_1 = require("../../common/uri/uri");
+const localize_1 = require("../../localization/localize");
+const constraintTracker_1 = require("../constraintTracker");
+const tuples_1 = require("../tuples");
+const types_1 = require("../types");
+const typeUtils_1 = require("../typeUtils");
+// Builds and specializes type variables and ParamSpecs; scoped evaluation stays in the evaluator.
+function createTypeVarHandling(context) {
+    const { addDiagnostic, assignClassToSelf, assignType, createSelfType, createTypeFormType, getBuiltInType, getObjectType, getTupleClassType, getTypeOfExpressionExpectingType, getTypeVarScopesForNode, isSymbolValidTypeExpression, isTypeFormClass, nodeInfo, rejectBareSpecialFormInTypeForm, solveAndApplyConstraints, specializeTypeAliasWithDefaults, typePromotions, updateUsageVariancesRecursive, } = context;
+    function expandTypedKwargs(functionType) {
+        const kwargsIndex = functionType.shared.parameters.findIndex((param) => param.category === 2 /* ParamCategory.KwargsDict */);
+        if (kwargsIndex < 0) {
+            return functionType;
+        }
+        (0, debug_1.assert)(kwargsIndex === functionType.shared.parameters.length - 1);
+        const kwargsType = types_1.FunctionType.getParamType(functionType, kwargsIndex);
+        if (!(0, types_1.isClassInstance)(kwargsType) || !types_1.ClassType.isTypedDictClass(kwargsType) || !kwargsType.priv.isUnpacked) {
+            return functionType;
+        }
+        const tdEntries = kwargsType.priv.typedDictNarrowedEntries ?? kwargsType.shared.typedDictEntries?.knownItems;
+        if (!tdEntries) {
+            return functionType;
+        }
+        const newFunction = types_1.FunctionType.clone(functionType);
+        newFunction.shared.parameters.splice(kwargsIndex);
+        if (newFunction.priv.specializedTypes) {
+            newFunction.priv.specializedTypes.parameterTypes.splice(kwargsIndex);
+        }
+        const kwSeparatorIndex = functionType.shared.parameters.findIndex((param) => param.category === 1 /* ParamCategory.ArgsList */);
+        // Add a keyword separator if necessary.
+        if (kwSeparatorIndex < 0 && tdEntries.size > 0) {
+            types_1.FunctionType.addKeywordOnlyParamSeparator(newFunction);
+        }
+        tdEntries.forEach((tdEntry, name) => {
+            // A TypedDict entry type may carry the TypedDict's own type parameters (e.g. an unpacked
+            // generic TypedDict `**kwargs: Unpack[TD[int]]`), so specialize each entry against the
+            // (possibly generic) TypedDict instance. Specializing an already-concrete type is a
+            // no-op, so this is safe for non-generic TypedDicts.
+            const specializedValueType = (0, typeUtils_1.partiallySpecializeType)(tdEntry.valueType, kwargsType, 
+            /* typeClassType */ undefined);
+            types_1.FunctionType.addParam(newFunction, types_1.FunctionParam.create(0 /* ParamCategory.Simple */, specializedValueType, types_1.FunctionParamFlags.TypeDeclared, name, tdEntry.isRequired ? undefined : specializedValueType));
+        });
+        const extraItemsType = kwargsType.shared.typedDictEntries?.extraItems?.valueType;
+        if (extraItemsType && !(0, types_1.isNever)(extraItemsType)) {
+            // Specialized for the same reason as the per-entry types above. This PEP 728
+            // `extra_items` branch uses the identical mechanism and is intentionally not
+            // separately tested.
+            const specializedExtraItemsType = (0, typeUtils_1.partiallySpecializeType)(extraItemsType, kwargsType, 
+            /* typeClassType */ undefined);
+            types_1.FunctionType.addParam(newFunction, types_1.FunctionParam.create(2 /* ParamCategory.KwargsDict */, specializedExtraItemsType, types_1.FunctionParamFlags.TypeDeclared, 'kwargs'));
+        }
+        return newFunction;
+    }
+    function expandPromotionTypes(node, type, excludeBytes = false) {
+        return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
+            if (!(0, types_1.isClass)(subtype) || !subtype.priv.includePromotions || subtype.priv.literalValue !== undefined) {
+                return subtype;
+            }
+            if (excludeBytes && types_1.ClassType.isBuiltIn(subtype, 'bytes')) {
+                return subtype;
+            }
+            const typesToCombine = [types_1.ClassType.cloneRemoveTypePromotions(subtype)];
+            const promotionTypeNames = typePromotions.get(subtype.shared.fullName);
+            if (promotionTypeNames) {
+                for (const promotionTypeName of promotionTypeNames) {
+                    const nameSplit = promotionTypeName.split('.');
+                    let promotionSubtype = getBuiltInType(node, nameSplit[nameSplit.length - 1]);
+                    if (promotionSubtype && (0, types_1.isInstantiableClass)(promotionSubtype)) {
+                        promotionSubtype = types_1.ClassType.cloneRemoveTypePromotions(promotionSubtype);
+                        if ((0, types_1.isClassInstance)(subtype)) {
+                            promotionSubtype = types_1.ClassType.cloneAsInstance(promotionSubtype);
+                        }
+                        promotionSubtype = (0, typeUtils_1.addConditionToType)(promotionSubtype, subtype.props?.condition);
+                        typesToCombine.push(promotionSubtype);
+                    }
+                }
+            }
+            return (0, types_1.combineTypes)(typesToCombine);
+        });
+    }
+    function makeTopLevelTypeVarsConcrete(type, makeParamSpecsConcrete = false, conditionFilter) {
+        type = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(type);
+        return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
+            if ((0, types_1.isParamSpec)(subtype)) {
+                if (subtype.priv.paramSpecAccess === 'args') {
+                    return (0, tuples_1.makeTupleObject)(context, [{ type: getObjectType(), isUnbounded: true }]);
+                }
+                else if (subtype.priv.paramSpecAccess === 'kwargs') {
+                    if (context.prefetched?.dictClass &&
+                        (0, types_1.isInstantiableClass)(context.prefetched.dictClass) &&
+                        context.prefetched?.strClass &&
+                        (0, types_1.isInstantiableClass)(context.prefetched.strClass)) {
+                        return types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(context.prefetched.dictClass, [
+                            (0, typeUtils_1.convertToInstance)(context.prefetched.strClass),
+                            getObjectType(),
+                        ]));
+                    }
+                    return types_1.UnknownType.create();
+                }
+            }
+            // If this is a function that contains only a ParamSpec (no additional
+            // parameters), convert it to a concrete type of (*args: Unknown, **kwargs: Unknown).
+            if (makeParamSpecsConcrete && (0, types_1.isFunction)(subtype)) {
+                const convertedType = (0, typeUtils_1.simplifyFunctionToParamSpec)(subtype);
+                if ((0, types_1.isParamSpec)(convertedType)) {
+                    return types_1.ParamSpecType.getUnknown();
+                }
+            }
+            if ((0, types_1.isTypeVarTuple)(subtype)) {
+                // If it's in a union, convert to type or object.
+                if (subtype.priv.isInUnion) {
+                    if (types_1.TypeBase.isInstantiable(subtype)) {
+                        if (context.prefetched?.typeClass && (0, types_1.isInstantiableClass)(context.prefetched.typeClass)) {
+                            return context.prefetched.typeClass;
+                        }
+                    }
+                    else {
+                        return getObjectType();
+                    }
+                    return types_1.AnyType.create();
+                }
+                // Fall back to "*tuple[object, ...]".
+                return (0, tuples_1.makeTupleObject)(context, [{ type: getObjectType(), isUnbounded: true }], /* isUnpacked */ true);
+            }
+            if ((0, types_1.isTypeVar)(subtype)) {
+                // If this is a recursive type alias placeholder
+                // that hasn't yet been resolved, return it as is.
+                if (subtype.shared.recursiveAlias) {
+                    return subtype;
+                }
+                if (types_1.TypeVarType.hasConstraints(subtype)) {
+                    const typesToCombine = [];
+                    // Expand the list of constrained subtypes, filtering out any that are
+                    // disallowed by the conditionFilter.
+                    subtype.shared.constraints.forEach((constraintType, constraintIndex) => {
+                        if (conditionFilter) {
+                            const typeVarName = types_1.TypeVarType.getNameWithScope(subtype);
+                            const applicableConstraint = conditionFilter.find((filter) => filter.typeVar.priv.nameWithScope === typeVarName);
+                            // If this type variable is being constrained to a single index,
+                            // don't include the other indices.
+                            if (applicableConstraint && applicableConstraint.constraintIndex !== constraintIndex) {
+                                return;
+                            }
+                        }
+                        if (types_1.TypeBase.isInstantiable(subtype)) {
+                            constraintType = (0, typeUtils_1.convertToInstantiable)(constraintType);
+                        }
+                        typesToCombine.push((0, typeUtils_1.addConditionToType)(constraintType, [{ typeVar: subtype, constraintIndex }]));
+                    });
+                    return (0, types_1.combineTypes)(typesToCombine);
+                }
+                if (subtype.shared.isExemptFromBoundCheck) {
+                    return types_1.AnyType.create();
+                }
+                // Fall back to a bound of "object" if no bound is provided.
+                let boundType = subtype.shared.boundType ?? getObjectType();
+                // If this is a synthesized self/cls type var, self-specialize its type arguments.
+                if (types_1.TypeVarType.isSelf(subtype) && (0, types_1.isClass)(boundType) && !types_1.ClassType.isPseudoGenericClass(boundType)) {
+                    boundType = (0, typeUtils_1.selfSpecializeClass)(boundType, {
+                        useBoundTypeVars: types_1.TypeVarType.isBound(subtype),
+                    });
+                }
+                if (subtype.priv.isUnpacked && (0, types_1.isClass)(boundType)) {
+                    boundType = types_1.ClassType.cloneForUnpacked(boundType);
+                }
+                boundType = types_1.TypeBase.isInstantiable(subtype) ? (0, typeUtils_1.convertToInstantiable)(boundType) : boundType;
+                return (0, typeUtils_1.addConditionToType)(boundType, [{ typeVar: subtype, constraintIndex: 0 }]);
+            }
+            return subtype;
+        });
+    }
+    function mapSubtypesExpandTypeVars(type, options, callback, recursionCount = 0) {
+        const newSubtypes = [];
+        let typeChanged = false;
+        function expandSubtype(unexpandedType, isLastSubtype) {
+            let expandedType = (0, types_1.isUnion)(unexpandedType) ? unexpandedType : makeTopLevelTypeVarsConcrete(unexpandedType);
+            expandedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expandedType);
+            if (options?.expandCallback) {
+                expandedType = options.expandCallback(expandedType);
+            }
+            (0, typeUtils_1.doForEachSubtype)(expandedType, (subtype, index, allSubtypes) => {
+                if (options?.conditionFilter) {
+                    const filteredType = applyConditionFilterToType(subtype, options.conditionFilter, recursionCount);
+                    if (!filteredType) {
+                        return undefined;
+                    }
+                    subtype = filteredType;
+                }
+                let transformedType = callback(subtype, unexpandedType, isLastSubtype && index === allSubtypes.length - 1);
+                if (transformedType !== unexpandedType) {
+                    typeChanged = true;
+                }
+                if (transformedType) {
+                    // Apply the type condition if it's associated with a constrained TypeVar.
+                    const typeCondition = (0, typeUtils_1.getTypeCondition)(subtype)?.filter((condition) => types_1.TypeVarType.hasConstraints(condition.typeVar));
+                    if (typeCondition && typeCondition.length > 0) {
+                        transformedType = (0, typeUtils_1.addConditionToType)(transformedType, typeCondition);
+                    }
+                    // This code path can often produce many duplicate subtypes. We can
+                    // reduce the cost of the combineTypes call below by filtering out these
+                    // duplicates proactively. Equal retained tuple literals can carry
+                    // different inference fallbacks, which combineTypes must reconcile.
+                    if (newSubtypes.length === 0 ||
+                        transformedType.props?.inferredTupleLiteral ||
+                        newSubtypes[newSubtypes.length - 1].props?.inferredTupleLiteral ||
+                        !(0, types_1.isTypeSame)(transformedType, newSubtypes[newSubtypes.length - 1])) {
+                        newSubtypes.push(transformedType);
+                    }
+                }
+                return undefined;
+            }, options?.sortSubtypes);
+        }
+        if ((0, types_1.isUnion)(type)) {
+            const subtypes = options?.sortSubtypes ? (0, typeUtils_1.sortTypes)(type.priv.subtypes) : type.priv.subtypes;
+            subtypes.forEach((subtype, index) => {
+                expandSubtype(subtype, index === type.priv.subtypes.length - 1);
+            });
+        }
+        else {
+            expandSubtype(type, /* isLastSubtype */ true);
+        }
+        if (!typeChanged) {
+            return type;
+        }
+        const newType = (0, types_1.combineTypes)(newSubtypes);
+        // Do our best to retain type aliases.
+        if (newType.category === 8 /* TypeCategory.Union */) {
+            types_1.UnionType.addTypeAliasSource(newType, type);
+        }
+        return newType;
+    }
+    function addTypeFormForSymbol(node, type, flags, includesVarDecl) {
+        const isIndexBase = node.parent?.nodeType === 27 /* ParseNodeType.Index */ && node.parent.d.leftExpr === node;
+        if ((flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0 && (0, types_1.isTypeVar)(type) && types_1.TypeVarType.isSelf(type)) {
+            type = types_1.TypeBase.cloneWithTypeForm(type, (0, typeUtils_1.convertToInstance)(type));
+        }
+        if ((flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0 && (0, types_1.isInstantiableClass)(type) && !isIndexBase) {
+            if (isTypeFormClass(type)) {
+                return createTypeFormType(type, node, /* typeArgs */ undefined);
+            }
+            const rejectedType = rejectBareSpecialFormInTypeForm(type, node);
+            if (rejectedType) {
+                return rejectedType;
+            }
+            if (types_1.ClassType.isBuiltIn(type, 'Self')) {
+                type = createSelfType(type, node, /* typeArgs */ undefined, flags);
+                if ((0, types_1.isTypeVar)(type)) {
+                    type = types_1.TypeBase.cloneWithTypeForm(type, (0, typeUtils_1.convertToInstance)(type));
+                }
+            }
+        }
+        const isValid = isSymbolValidTypeExpression(type, includesVarDecl);
+        // If the type already has type information associated with it, don't replace.
+        if (type.props?.typeForm) {
+            // If the NoConvertSpecialForm flag is set, we are evaluating in
+            // the interior of a type expression, so variables are not allowed.
+            // Clear any existing type form type for this symbol in this case.
+            if ((flags & 33554432 /* EvalFlags.NoConvertSpecialForm */) !== 0 && !isValid) {
+                type = types_1.TypeBase.cloneWithTypeForm(type, undefined);
+            }
+            return type;
+        }
+        // If the symbol is not valid for a type expression (e.g. it's a variable),
+        // don't add TypeForm info.
+        if (!isValid) {
+            return type;
+        }
+        if ((0, types_1.isTypeVar)(type) && type.priv.scopeId && !type.shared.isSynthesized) {
+            if (!(0, types_1.isTypeVarTuple)(type) || !type.priv.isInUnion) {
+                const liveScopeIds = getTypeVarScopesForNode(node);
+                type = types_1.TypeBase.cloneWithTypeForm(type, (0, typeUtils_1.convertToInstance)((0, typeUtils_1.makeTypeVarsBound)(type, liveScopeIds)));
+            }
+        }
+        else if ((0, types_1.isInstantiableClass)(type) && !type.priv.includeSubclasses && !types_1.ClassType.isSpecialBuiltIn(type)) {
+            if (types_1.ClassType.isBuiltIn(type, 'Any')) {
+                type = types_1.TypeBase.cloneWithTypeForm(type, types_1.AnyType.create());
+            }
+            else {
+                type = types_1.TypeBase.cloneWithTypeForm(type, types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeWithDefaultTypeArgs)(type)));
+            }
+        }
+        if (type.props?.typeAliasInfo && types_1.TypeBase.isInstantiable(type)) {
+            let typeFormType = type;
+            if ((flags & 2 /* EvalFlags.NoSpecialize */) === 0) {
+                typeFormType = specializeTypeAliasWithDefaults(typeFormType, /* errorNode */ undefined);
+            }
+            type = types_1.TypeBase.cloneWithTypeForm(type, (0, typeUtils_1.convertToInstance)(typeFormType));
+        }
+        return type;
+    }
+    function inferVarianceForTypeAlias(type) {
+        const aliasInfo = type.props?.typeAliasInfo;
+        // If this isn't a generic type alias, there's nothing to do.
+        if (!aliasInfo || !aliasInfo.shared.typeParams) {
+            return undefined;
+        }
+        // Is the computed variance info already cached?
+        if (aliasInfo.shared.computedVariance) {
+            return aliasInfo.shared.computedVariance;
+        }
+        const typeParams = aliasInfo.shared.typeParams;
+        // Start with all of the usage variances unknown.
+        const usageVariances = typeParams.map(() => 1 /* Variance.Unknown */);
+        // Prepopulate the cached value for the type alias to handle
+        // recursive type aliases.
+        aliasInfo.shared.computedVariance = usageVariances;
+        // Traverse the type alias type definition and adjust the usage
+        // variances accordingly.
+        updateUsageVariancesRecursive(type, typeParams, usageVariances, 3 /* Variance.Covariant */);
+        return usageVariances;
+    }
+    function getUnknownExemptTypeVarsForReturnType(functionType, returnType) {
+        if ((0, types_1.isFunction)(returnType) && !returnType.shared.name) {
+            const returnTypeScopeId = returnType.shared.typeVarScopeId;
+            // If one or more type vars found within the return type are scoped to
+            // the functionType but don't appear anywhere else within the functionType's
+            // input parameters, rescope them to the return type callable so they are
+            // not replaced with Unknown.
+            if (returnTypeScopeId && functionType.shared.typeVarScopeId) {
+                let typeVarsInReturnType = (0, typeUtils_1.getTypeVarArgsRecursive)(returnType);
+                // Remove any type variables that appear in the function's input parameters.
+                functionType.shared.parameters.forEach((param, index) => {
+                    if (types_1.FunctionParam.isTypeDeclared(param)) {
+                        const typeVarsInInputParam = (0, typeUtils_1.getTypeVarArgsRecursive)(types_1.FunctionType.getParamType(functionType, index));
+                        typeVarsInReturnType = typeVarsInReturnType.filter((returnTypeVar) => !typeVarsInInputParam.some((inputTypeVar) => (0, types_1.isTypeSame)(returnTypeVar, inputTypeVar)));
+                    }
+                });
+                return typeVarsInReturnType;
+            }
+        }
+        return [];
+    }
+    function createTypeVarType(errorNode, classType, argList) {
+        let typeVarName = '';
+        let firstConstraintArg;
+        let defaultValueNode;
+        if (argList.length === 0) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarFirstArg(), errorNode);
+            return undefined;
+        }
+        const firstArg = argList[0];
+        if (firstArg.valueExpression && firstArg.valueExpression.nodeType === 48 /* ParseNodeType.StringList */) {
+            typeVarName = firstArg.valueExpression.d.strings.map((s) => s.d.value).join('');
+        }
+        else {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarFirstArg(), firstArg.valueExpression || errorNode);
+        }
+        const typeVar = types_1.TypeBase.cloneAsSpecialForm(types_1.TypeVarType.createInstantiable(typeVarName), types_1.ClassType.cloneAsInstance(classType));
+        // Parse the remaining parameters.
+        const paramNameMap = new Map();
+        for (let i = 1; i < argList.length; i++) {
+            const paramNameNode = argList[i].name;
+            const paramName = paramNameNode ? paramNameNode.d.value : undefined;
+            if (paramName) {
+                if (paramNameMap.get(paramName)) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.duplicateParam().format({ name: paramName }), argList[i].valueExpression || errorNode);
+                }
+                if (paramName === 'bound') {
+                    if (types_1.TypeVarType.hasConstraints(typeVar)) {
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarBoundAndConstrained(), argList[i].valueExpression || errorNode);
+                    }
+                    else {
+                        const argType = argList[i].typeResult?.type ??
+                            getTypeOfExpressionExpectingType(argList[i].valueExpression, {
+                                noNonTypeSpecialForms: true,
+                                typeExpression: true,
+                                parsesStringLiteral: true,
+                            }).type;
+                        if ((0, typeUtils_1.requiresSpecialization)(argType, { ignorePseudoGeneric: true, ignoreImplicitTypeArgs: true })) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarBoundGeneric(), argList[i].valueExpression || errorNode);
+                        }
+                        typeVar.shared.boundType = (0, typeUtils_1.convertToInstance)(argType);
+                    }
+                }
+                else if (paramName === 'covariant') {
+                    if (argList[i].valueExpression && getBooleanValue(argList[i].valueExpression)) {
+                        if (typeVar.shared.declaredVariance === 4 /* Variance.Contravariant */ ||
+                            typeVar.shared.declaredVariance === 0 /* Variance.Auto */) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarVariance(), argList[i].valueExpression);
+                        }
+                        else {
+                            typeVar.shared.declaredVariance = 3 /* Variance.Covariant */;
+                        }
+                    }
+                }
+                else if (paramName === 'contravariant') {
+                    if (argList[i].valueExpression && getBooleanValue(argList[i].valueExpression)) {
+                        if (typeVar.shared.declaredVariance === 3 /* Variance.Covariant */ ||
+                            typeVar.shared.declaredVariance === 0 /* Variance.Auto */) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarVariance(), argList[i].valueExpression);
+                        }
+                        else {
+                            typeVar.shared.declaredVariance = 4 /* Variance.Contravariant */;
+                        }
+                    }
+                }
+                else if (paramName === 'infer_variance') {
+                    if (argList[i].valueExpression && getBooleanValue(argList[i].valueExpression)) {
+                        if (typeVar.shared.declaredVariance === 3 /* Variance.Covariant */ ||
+                            typeVar.shared.declaredVariance === 4 /* Variance.Contravariant */) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarVariance(), argList[i].valueExpression);
+                        }
+                        else {
+                            typeVar.shared.declaredVariance = 0 /* Variance.Auto */;
+                        }
+                    }
+                }
+                else if (paramName === 'default') {
+                    defaultValueNode = argList[i].valueExpression;
+                    const argType = argList[i].typeResult?.type ??
+                        getTypeOfExpressionExpectingType(defaultValueNode, {
+                            allowTypeVarsWithoutScopeId: true,
+                            typeExpression: true,
+                        }).type;
+                    typeVar.shared.defaultType = (0, typeUtils_1.convertToInstance)(argType);
+                    typeVar.shared.isDefaultExplicit = true;
+                    const fileInfo = nodeInfo.getFileInfo(errorNode);
+                    if (!fileInfo.isStubFile &&
+                        pythonVersion_1.PythonVersion.isLessThan(fileInfo.executionEnvironment.pythonVersion, pythonVersion_1.pythonVersion3_13) &&
+                        classType.shared.moduleName !== 'typing_extensions') {
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarDefaultIllegal(), defaultValueNode);
+                    }
+                }
+                else {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.typeVarUnknownParam().format({ name: paramName }), argList[i].node?.d.name || argList[i].valueExpression || errorNode);
+                }
+                paramNameMap.set(paramName, paramName);
+            }
+            else {
+                if (types_1.TypeVarType.hasBound(typeVar)) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarBoundAndConstrained(), argList[i].valueExpression || errorNode);
+                }
+                else {
+                    const argType = argList[i].typeResult?.type ??
+                        getTypeOfExpressionExpectingType(argList[i].valueExpression, {
+                            typeExpression: true,
+                        }).type;
+                    if ((0, typeUtils_1.requiresSpecialization)(argType, { ignorePseudoGeneric: true })) {
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarConstraintGeneric(), argList[i].valueExpression || errorNode);
+                    }
+                    types_1.TypeVarType.addConstraint(typeVar, (0, typeUtils_1.convertToInstance)(argType));
+                    if (firstConstraintArg === undefined) {
+                        firstConstraintArg = argList[i];
+                    }
+                }
+            }
+        }
+        if (typeVar.shared.constraints.length === 1 && firstConstraintArg) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarSingleConstraint(), firstConstraintArg.valueExpression || errorNode);
+        }
+        // If a default is provided, make sure it is compatible with the bound
+        // or constraint.
+        if (typeVar.shared.isDefaultExplicit && defaultValueNode) {
+            verifyTypeVarDefaultIsCompatible(typeVar, defaultValueNode);
+        }
+        return typeVar;
+    }
+    function verifyTypeVarDefaultIsCompatible(typeVar, defaultValueNode) {
+        (0, debug_1.assert)(typeVar.shared.isDefaultExplicit);
+        const constraints = new constraintTracker_1.ConstraintTracker();
+        const concreteDefaultType = makeTopLevelTypeVarsConcrete(solveAndApplyConstraints(typeVar.shared.defaultType, constraints, {
+            replaceUnsolved: {
+                scopeIds: (0, typeUtils_1.getTypeVarScopeIds)(typeVar),
+                tupleClassType: getTupleClassType(),
+            },
+        }));
+        if (typeVar.shared.boundType) {
+            if (!assignType(typeVar.shared.boundType, concreteDefaultType)) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarDefaultBoundMismatch(), defaultValueNode);
+            }
+        }
+        else if (types_1.TypeVarType.hasConstraints(typeVar)) {
+            let isConstraintCompatible = true;
+            // If the default type is a constrained TypeVar, make sure all of its constraints
+            // are also constraints in typeVar. If the default type is not a constrained TypeVar,
+            // use its concrete type to compare against the constraints.
+            if ((0, types_1.isTypeVar)(typeVar.shared.defaultType) && types_1.TypeVarType.hasConstraints(typeVar.shared.defaultType)) {
+                for (const constraint of typeVar.shared.defaultType.shared.constraints) {
+                    if (!typeVar.shared.constraints.some((c) => (0, types_1.isTypeSame)(c, constraint))) {
+                        isConstraintCompatible = false;
+                    }
+                }
+            }
+            else if (!typeVar.shared.constraints.some((constraint) => (0, types_1.isTypeSame)(constraint, concreteDefaultType, { ignoreConditions: true }))) {
+                isConstraintCompatible = false;
+            }
+            if (!isConstraintCompatible) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarDefaultConstraintMismatch(), defaultValueNode);
+            }
+        }
+    }
+    function getTypeVarTupleDefaultType(node, isPep695Syntax) {
+        const argType = getTypeOfExpressionExpectingType(node, {
+            allowUnpackedTuple: true,
+            allowTypeVarsWithoutScopeId: true,
+            forwardRefs: isPep695Syntax,
+            typeExpression: true,
+        }).type;
+        const isUnpackedTuple = (0, types_1.isClass)(argType) && (0, typeUtils_1.isTupleClass)(argType) && argType.priv.isUnpacked;
+        const isUnpackedTypeVar = (0, types_1.isUnpackedTypeVarTuple)(argType);
+        if (!isUnpackedTuple && !isUnpackedTypeVar) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarTupleDefaultNotUnpacked(), node);
+            return undefined;
+        }
+        return (0, typeUtils_1.convertToInstance)(argType);
+    }
+    function createTypeVarTupleType(errorNode, classType, argList) {
+        let typeVarName = '';
+        if (argList.length === 0) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.typeVarFirstArg(), errorNode);
+            return undefined;
+        }
+        const firstArg = argList[0];
+        if (firstArg.valueExpression && firstArg.valueExpression.nodeType === 48 /* ParseNodeType.StringList */) {
+            typeVarName = firstArg.valueExpression.d.strings.map((s) => s.d.value).join('');
+        }
+        else {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarFirstArg(), firstArg.valueExpression || errorNode);
+        }
+        const typeVar = types_1.TypeBase.cloneAsSpecialForm(types_1.TypeVarType.createInstantiable(typeVarName, types_1.TypeVarKind.TypeVarTuple), types_1.ClassType.cloneAsInstance(classType));
+        typeVar.shared.defaultType = (0, tuples_1.makeTupleObject)(context, [{ type: types_1.UnknownType.create(), isUnbounded: true }]);
+        // Parse the remaining parameters.
+        for (let i = 1; i < argList.length; i++) {
+            const paramNameNode = argList[i].name;
+            const paramName = paramNameNode ? paramNameNode.d.value : undefined;
+            if (paramName) {
+                if (paramName === 'default') {
+                    const expr = argList[i].valueExpression;
+                    if (expr) {
+                        const defaultType = getTypeVarTupleDefaultType(expr, /* isPep695Syntax */ false);
+                        if (defaultType) {
+                            typeVar.shared.defaultType = defaultType;
+                            typeVar.shared.isDefaultExplicit = true;
+                        }
+                    }
+                    const fileInfo = nodeInfo.getFileInfo(errorNode);
+                    if (!fileInfo.isStubFile &&
+                        pythonVersion_1.PythonVersion.isLessThan(fileInfo.executionEnvironment.pythonVersion, pythonVersion_1.pythonVersion3_13) &&
+                        classType.shared.moduleName !== 'typing_extensions') {
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarDefaultIllegal(), expr);
+                    }
+                }
+                else {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarTupleUnknownParam().format({ name: argList[i].name?.d.value || '?' }), argList[i].node?.d.name || argList[i].valueExpression || errorNode);
+                }
+            }
+            else {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarTupleConstraints(), argList[i].valueExpression || errorNode);
+            }
+        }
+        return typeVar;
+    }
+    function getPseudoGenericTypeVarName(paramName) {
+        return `__type_of_${paramName}`;
+    }
+    function inferVarianceForClass(classType) {
+        if (!classType.shared.requiresVarianceInference) {
+            return;
+        }
+        // Presumptively mark the variance inference as complete. This
+        // prevents potential recursion.
+        classType.shared.requiresVarianceInference = false;
+        // Presumptively mark the computed variance to "unknown". We'll
+        // replace this below once the variance has been inferred.
+        classType.shared.typeParams.forEach((param) => {
+            if (param.shared.declaredVariance === 0 /* Variance.Auto */) {
+                param.priv.computedVariance = 1 /* Variance.Unknown */;
+            }
+        });
+        const dummyTypeObject = types_1.ClassType.createInstantiable('__varianceDummy', '', '', uri_1.Uri.empty(), 0, 0, undefined, undefined);
+        classType.shared.typeParams.forEach((param, paramIndex) => {
+            // Skip TypeVarTuples and ParamSpecs.
+            if ((0, types_1.isTypeVarTuple)(param) || (0, types_1.isParamSpec)(param)) {
+                return;
+            }
+            // Skip type variables without auto-variance.
+            if (param.shared.declaredVariance !== 0 /* Variance.Auto */) {
+                return;
+            }
+            // Replace all type arguments with a dummy type except for the
+            // TypeVar of interest, which is replaced with an object instance.
+            const srcTypeArgs = classType.shared.typeParams.map((p, i) => {
+                if ((0, types_1.isTypeVarTuple)(p)) {
+                    return p;
+                }
+                return i === paramIndex ? getObjectType() : dummyTypeObject;
+            });
+            // Replace all type arguments with a dummy type except for the
+            // TypeVar of interest, which is replaced with itself.
+            const destTypeArgs = classType.shared.typeParams.map((p, i) => {
+                return i === paramIndex || (0, types_1.isTypeVarTuple)(p) ? p : dummyTypeObject;
+            });
+            const srcType = types_1.ClassType.specialize(classType, srcTypeArgs);
+            const destType = types_1.ClassType.specialize(classType, destTypeArgs);
+            const isDestSubtypeOfSrc = assignClassToSelf(srcType, destType, 3 /* Variance.Covariant */, 
+            /* ignoreBaseClassVariance */ false);
+            let inferredVariance;
+            if (isDestSubtypeOfSrc) {
+                inferredVariance = 3 /* Variance.Covariant */;
+            }
+            else {
+                const isSrcSubtypeOfDest = assignClassToSelf(destType, srcType, 4 /* Variance.Contravariant */, 
+                /* ignoreBaseClassVariance */ false);
+                if (isSrcSubtypeOfDest) {
+                    inferredVariance = 4 /* Variance.Contravariant */;
+                }
+                else {
+                    inferredVariance = 2 /* Variance.Invariant */;
+                }
+            }
+            // We assume here that we don't need to clone the type var object
+            // because it was already cloned when it was associated with this
+            // class scope.
+            classType.shared.typeParams[paramIndex].priv.computedVariance = inferredVariance;
+        });
+    }
+    function convertToTypeFormType(expectedType, srcType) {
+        // Is the source is a TypeForm type?
+        if (!srcType.props?.typeForm) {
+            return srcType;
+        }
+        let srcTypeFormType;
+        // Is the source is a TypeForm type?
+        if (srcType.props?.typeForm) {
+            srcTypeFormType = srcType.props.typeForm;
+        }
+        else if ((0, types_1.isClass)(srcType)) {
+            if (types_1.TypeBase.isInstantiable(srcType)) {
+                if (!types_1.ClassType.isSpecialBuiltIn(srcType)) {
+                    srcTypeFormType = types_1.ClassType.cloneAsInstance(srcType);
+                }
+            }
+            else if (types_1.ClassType.isBuiltIn(srcType, 'type')) {
+                srcTypeFormType =
+                    srcType.priv.typeArgs?.length && srcType.priv.typeArgs.length > 0
+                        ? srcType.priv.typeArgs[0]
+                        : types_1.UnknownType.create();
+            }
+        }
+        else if ((0, types_1.isTypeVar)(srcType) && types_1.TypeBase.isInstantiable(srcType)) {
+            if (!(0, types_1.isTypeVarTuple)(srcType) || !srcType.priv.isInUnion) {
+                srcTypeFormType = (0, typeUtils_1.convertToInstance)(srcType);
+            }
+        }
+        if (!srcTypeFormType) {
+            return srcType;
+        }
+        let resultType;
+        (0, typeUtils_1.doForEachSubtype)(expectedType, (subtype) => {
+            if (resultType || !(0, types_1.isClassInstance)(subtype) || !types_1.ClassType.isBuiltIn(subtype, 'TypeForm')) {
+                return;
+            }
+            const destTypeFormType = subtype.priv.typeArgs && subtype.priv.typeArgs.length > 0 ? subtype.priv.typeArgs[0] : types_1.AnyType.create();
+            if (assignType(destTypeFormType, srcTypeFormType)) {
+                resultType = types_1.ClassType.specialize(subtype, [srcTypeFormType]);
+            }
+        });
+        return resultType ?? srcType;
+    }
+    function setConstraintsForFreeTypeVars(destType, srcType, constraints) {
+        const typeVars = (0, typeUtils_1.getTypeVarArgsRecursive)(destType);
+        typeVars.forEach((typeVar) => {
+            if (!types_1.TypeVarType.isBound(typeVar) && !constraints.getMainConstraintSet().getTypeVar(typeVar)) {
+                // Don't set ParamSpecs or TypeVarTuples.
+                if (!(0, types_1.isParamSpec)(srcType) && !(0, types_1.isTypeVarTuple)(srcType)) {
+                    constraints.setBounds(typeVar, srcType);
+                }
+            }
+        });
+    }
+    function applyConditionFilterToType(type, conditionFilter, recursionCount) {
+        if (recursionCount > types_1.maxTypeRecursionCount) {
+            return type;
+        }
+        recursionCount++;
+        // If the type has a condition associated with it, make sure it's compatible.
+        if (!types_1.TypeCondition.isCompatible((0, typeUtils_1.getTypeCondition)(type), conditionFilter)) {
+            return undefined;
+        }
+        // If the type is generic, see if any of its type arguments should be filtered.
+        // This is possible only in cases where the type parameter is covariant.
+        // TODO - handle functions and tuples
+        if ((0, types_1.isClass)(type) && type.priv.typeArgs && !type.priv.tupleTypeArgs) {
+            inferVarianceForClass(type);
+            let typeWasTransformed = false;
+            const filteredTypeArgs = type.priv.typeArgs.map((typeArg, index) => {
+                if (index >= type.shared.typeParams.length) {
+                    return typeArg;
+                }
+                const variance = types_1.TypeVarType.getVariance(type.shared.typeParams[index]);
+                if (variance !== 3 /* Variance.Covariant */) {
+                    return typeArg;
+                }
+                // Don't expand recursive type aliases because they can
+                // cause infinite recursion.
+                if ((0, types_1.isTypeVar)(typeArg) && typeArg.shared.recursiveAlias) {
+                    return typeArg;
+                }
+                const filteredTypeArg = mapSubtypesExpandTypeVars(typeArg, { conditionFilter }, (expandedSubtype) => {
+                    return expandedSubtype;
+                }, recursionCount);
+                if (filteredTypeArg !== typeArg) {
+                    typeWasTransformed = true;
+                }
+                return filteredTypeArg;
+            });
+            if (typeWasTransformed) {
+                return types_1.ClassType.specialize(type, filteredTypeArgs);
+            }
+        }
+        return type;
+    }
+    function getBooleanValue(node) {
+        if (node.nodeType === 14 /* ParseNodeType.Constant */) {
+            if (node.d.constType === 15 /* KeywordType.False */) {
+                return false;
+            }
+            else if (node.d.constType === 34 /* KeywordType.True */) {
+                return true;
+            }
+        }
+        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.expectedBoolLiteral(), node);
+        return false;
+    }
+    return {
+        expandTypedKwargs,
+        expandPromotionTypes,
+        makeTopLevelTypeVarsConcrete,
+        mapSubtypesExpandTypeVars,
+        addTypeFormForSymbol,
+        inferVarianceForTypeAlias,
+        getUnknownExemptTypeVarsForReturnType,
+        createTypeVarType,
+        createTypeVarTupleType,
+        verifyTypeVarDefaultIsCompatible,
+        getTypeVarTupleDefaultType,
+        getPseudoGenericTypeVarName,
+        inferVarianceForClass,
+        convertToTypeFormType,
+        setConstraintsForFreeTypeVars,
+    };
+}
+//# sourceMappingURL=typeVarHandling.js.map