@zzzen/pyright-internal 1.2.0-dev.20240128 → 1.2.0-dev.20240218

package/dist/analyzer/typeEvaluator.js

@@ -494,7 +494,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 (0, types_1.isInstantiableClass)(objectClass) &&
                 typeClassType &&
                 (0, types_1.isInstantiableClass)(typeClassType)) {
-                const anyClass = types_1.ClassType.createInstantiable('Any', 'typing.Any', 'typing', uri_1.Uri.empty(), 1 /* ClassTypeFlags.BuiltInClass */, 
+                const anyClass = types_1.ClassType.createInstantiable('Any', 'typing.Any', 'typing', uri_1.Uri.empty(), 1 /* ClassTypeFlags.BuiltInClass */ | 1073741824 /* ClassTypeFlags.SpecialFormClass */, 
                 /* typeSourceId */ -1, 
                 /* declaredMetaclass */ undefined, 
                 /* effectiveMetaclass */ typeClassType);
@@ -1002,11 +1002,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function stripLiteralValue(type) {
         var _a, _b, _c;
         // Handle the not-uncommon case where the type is a union that consists
-        // only of literal str or literal int values.
+        // only of literal values.
         if ((0, types_1.isUnion)(type) && type.subtypes.length > 0) {
-            if (((_a = type.literalStrMap) === null || _a === void 0 ? void 0 : _a.size) === type.subtypes.length ||
-                ((_b = type.literalIntMap) === null || _b === void 0 ? void 0 : _b.size) === type.subtypes.length ||
-                ((_c = type.literalEnumMap) === null || _c === void 0 ? void 0 : _c.size) === type.subtypes.length) {
+            if (((_a = type.literalInstances.literalStrMap) === null || _a === void 0 ? void 0 : _a.size) === type.subtypes.length ||
+                ((_b = type.literalInstances.literalIntMap) === null || _b === void 0 ? void 0 : _b.size) === type.subtypes.length ||
+                ((_c = type.literalInstances.literalEnumMap) === null || _c === void 0 ? void 0 : _c.size) === type.subtypes.length) {
                 return stripLiteralValue(type.subtypes[0]);
             }
         }
@@ -1392,7 +1392,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // an instance of a class. Limit access to metaclass instance members
             // in this case.
             if (!objectTypeIsInstantiable) {
-                effectiveFlags |= 32 /* MemberAccessFlags.SkipClassMembers */ | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */;
+                effectiveFlags |=
+                    32 /* MemberAccessFlags.SkipClassMembers */ |
+                        512 /* MemberAccessFlags.SkipAttributeAccessOverride */ |
+                        8 /* MemberAccessFlags.SkipTypeBaseClass */;
                 effectiveFlags &= ~16 /* MemberAccessFlags.SkipInstanceMembers */;
             }
             const metaclassDiag = diag ? new diagnostic_1.DiagnosticAddendum() : undefined;
@@ -1779,8 +1782,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let isValidIterator = true;
         let type = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(typeResult.type);
         type = makeTopLevelTypeVarsConcrete(type);
-        if ((0, typeUtils_1.isOptionalType)(type)) {
-            if (!typeResult.isIncomplete && emitNotIterableError) {
+        type = (0, types_1.removeUnbound)(type);
+        if ((0, typeUtils_1.isOptionalType)(type) && emitNotIterableError) {
+            if (!typeResult.isIncomplete) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOptionalIterable, localize_1.LocMessage.noneNotIterable(), errorNode);
             }
             type = (0, typeUtils_1.removeNoneFromUnion)(type);
@@ -2418,15 +2422,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 });
                 // Have we accounted for all of the targets and sources? If not, we have a size mismatch.
                 if (sourceEntryTypes.length !== targetExpressions.length) {
-                    const expectedEntryCount = unpackIndex >= 0 ? targetExpressions.length - 1 : targetExpressions.length;
                     const subDiag = diagAddendum.createAddendum();
                     subDiag.addMessage((target.nodeType === 31 /* ParseNodeType.List */
                         ? localize_1.LocAddendum.listAssignmentMismatch()
                         : localize_1.LocAddendum.tupleAssignmentMismatch()).format({
                         type: printType(subtype),
                     }));
-                    subDiag.createAddendum().addMessage(localize_1.LocAddendum.tupleSizeMismatch().format({
-                        expected: expectedEntryCount,
+                    subDiag.createAddendum().addMessage((unpackIndex >= 0
+                        ? localize_1.LocAddendum.tupleSizeMismatchIndeterminateDest()
+                        : localize_1.LocAddendum.tupleSizeMismatch()).format({
+                        expected: unpackIndex >= 0 ? targetExpressions.length - 1 : targetExpressions.length,
                         received: sourceEntryTypes.length,
                     }));
                 }
@@ -2493,11 +2498,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             var _a, _b;
             if ((0, types_1.isParamSpec)(subtype)) {
                 if (subtype.paramSpecAccess === 'args') {
-                    if (tupleClassType &&
-                        (0, types_1.isInstantiableClass)(tupleClassType) &&
-                        objectType &&
-                        (0, types_1.isClassInstance)(objectType)) {
-                        return types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, [{ type: objectType, isUnbounded: true }]));
+                    if (objectType && (0, types_1.isClassInstance)(objectType)) {
+                        return makeTupleObject([{ type: objectType, isUnbounded: true }]);
                     }
                     return types_1.UnknownType.create();
                 }
@@ -3282,9 +3284,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     defaultType = (0, typeUtils_1.applySolvedTypeVars)(param, typeVarContext, { unknownIfNotFound: true });
                 }
                 else if (param.details.isVariadic && tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
-                    defaultType = types_1.ClassType.cloneForUnpacked((0, typeUtils_1.specializeTupleClass)(types_1.ClassType.cloneAsInstance(tupleClassType), [
-                        { type: types_1.UnknownType.create(), isUnbounded: true },
-                    ]));
+                    defaultType = makeTupleObject([{ type: types_1.UnknownType.create(), isUnbounded: true }], 
+                    /* isUnpackedTuple */ true);
                 }
                 else {
                     defaultType = types_1.UnknownType.create();
@@ -3904,18 +3905,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             else {
                 resultType = subtype;
             }
-            // If this is a "set" operation, we have a bit more work to do.
-            if (usage.method !== 'set') {
+            // If this is a "set" or "delete" operation, we have a bit more work to do.
+            if (usage.method === 'get') {
                 return resultType;
             }
-            // Check for an attempt to overwrite a ClassVar member from an instance.
+            // Check for an attempt to overwrite or delete a ClassVar member from an instance.
             if (!isDescriptorApplied &&
                 (memberInfo === null || memberInfo === void 0 ? void 0 : memberInfo.symbol.isClassVar()) &&
                 (flags & 128 /* MemberAccessFlags.DisallowClassVarWrites */) !== 0) {
                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.memberSetClassVar().format({ name: memberName }));
                 isDescriptorError = true;
             }
-            // Check for an attempt to overwrite a final member variable.
+            // Check for an attempt to overwrite or delete a final member variable.
             const finalVarTypeDecl = memberInfo === null || memberInfo === void 0 ? void 0 : memberInfo.symbol.getDeclarations().find((decl) => isFinalVariableDeclaration(decl));
             if (finalVarTypeDecl &&
                 errorNode &&
@@ -3928,7 +3929,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     isDescriptorError = true;
                 }
             }
-            // Check for an attempt to overwrite an instance variable that is
+            // Check for an attempt to overwrite or delete an instance variable that is
             // read-only (e.g. in a named tuple).
             if ((memberInfo === null || memberInfo === void 0 ? void 0 : memberInfo.isInstanceMember) &&
                 (0, types_1.isClass)(memberInfo.classType) &&
@@ -4444,55 +4445,49 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // param somewhere in the list?
         if (variadicIndex >= 0) {
             const variadicTypeVar = typeParameters[variadicIndex];
-            if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
-                if (variadicIndex < typeArgs.length) {
-                    const variadicTypeResults = typeArgs.slice(variadicIndex, variadicIndex + 1 + typeArgs.length - typeParameters.length);
-                    // If the type args consist of a lone variadic type variable, don't wrap it in a tuple.
-                    if (variadicTypeResults.length === 1 && (0, types_1.isVariadicTypeVar)(variadicTypeResults[0].type)) {
-                        validateVariadicTypeVarIsUnpacked(variadicTypeResults[0].type, variadicTypeResults[0].node);
-                    }
-                    else {
-                        variadicTypeResults.forEach((arg, index) => {
-                            validateTypeArg(arg, {
-                                allowEmptyTuple: index === 0,
-                                allowVariadicTypeVar: true,
-                                allowUnpackedTuples: true,
-                            });
+            if (variadicIndex < typeArgs.length) {
+                const variadicTypeResults = typeArgs.slice(variadicIndex, variadicIndex + 1 + typeArgs.length - typeParameters.length);
+                // If the type args consist of a lone variadic type variable, don't wrap it in a tuple.
+                if (variadicTypeResults.length === 1 && (0, types_1.isVariadicTypeVar)(variadicTypeResults[0].type)) {
+                    validateVariadicTypeVarIsUnpacked(variadicTypeResults[0].type, variadicTypeResults[0].node);
+                }
+                else {
+                    variadicTypeResults.forEach((arg, index) => {
+                        validateTypeArg(arg, {
+                            allowEmptyTuple: index === 0,
+                            allowVariadicTypeVar: true,
+                            allowUnpackedTuples: true,
                         });
-                        const variadicTypes = [];
-                        if (variadicTypeResults.length !== 1 || !variadicTypeResults[0].isEmptyTupleShorthand) {
-                            variadicTypeResults.forEach((typeResult) => {
-                                if ((0, types_1.isUnpackedClass)(typeResult.type) && typeResult.type.tupleTypeArguments) {
-                                    (0, collectionUtils_1.appendArray)(variadicTypes, typeResult.type.tupleTypeArguments);
-                                }
-                                else {
-                                    variadicTypes.push({
-                                        type: (0, typeUtils_1.convertToInstance)(typeResult.type),
-                                        isUnbounded: false,
-                                    });
-                                }
-                            });
-                        }
-                        const tupleObject = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, variadicTypes, 
-                        /* isTypeArgumentExplicit */ true, 
-                        /* isUnpackedTuple */ true));
-                        typeArgs = [
-                            ...typeArgs.slice(0, variadicIndex),
-                            { node: typeArgs[variadicIndex].node, type: tupleObject },
-                            ...typeArgs.slice(variadicIndex + 1 + typeArgs.length - typeParameters.length, typeArgs.length),
-                        ];
-                    }
-                }
-                else if (!variadicTypeVar.details.defaultType) {
-                    // Add an empty tuple that maps to the TypeVarTuple type parameter.
-                    typeArgs.push({
-                        node: errorNode,
-                        type: (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, [], 
-                        /* isTypeArgumentExplicit */ true, 
-                        /* isUnpackedTuple */ true)),
                     });
+                    const variadicTypes = [];
+                    if (variadicTypeResults.length !== 1 || !variadicTypeResults[0].isEmptyTupleShorthand) {
+                        variadicTypeResults.forEach((typeResult) => {
+                            if ((0, types_1.isUnpackedClass)(typeResult.type) && typeResult.type.tupleTypeArguments) {
+                                (0, collectionUtils_1.appendArray)(variadicTypes, typeResult.type.tupleTypeArguments);
+                            }
+                            else {
+                                variadicTypes.push({
+                                    type: (0, typeUtils_1.convertToInstance)(typeResult.type),
+                                    isUnbounded: false,
+                                });
+                            }
+                        });
+                    }
+                    const tupleObject = makeTupleObject(variadicTypes, /* isUnpackedTuple */ true);
+                    typeArgs = [
+                        ...typeArgs.slice(0, variadicIndex),
+                        { node: typeArgs[variadicIndex].node, type: tupleObject },
+                        ...typeArgs.slice(variadicIndex + 1 + typeArgs.length - typeParameters.length, typeArgs.length),
+                    ];
                 }
             }
+            else if (!variadicTypeVar.details.defaultType) {
+                // Add an empty tuple that maps to the TypeVarTuple type parameter.
+                typeArgs.push({
+                    node: errorNode,
+                    type: makeTupleObject([], /* isUnpackedTuple */ true),
+                });
+            }
         }
         return typeArgs;
     }
@@ -4936,11 +4931,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         });
     }
-    function makeTupleObject(entryTypes, isUnspecifiedLength = false) {
+    function makeTupleObject(typeArgs, isUnpackedTuple = false) {
         if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
-            return (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, entryTypes.map((t) => {
-                return { type: t, isUnbounded: isUnspecifiedLength };
-            })));
+            return (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, typeArgs, /* isTypeArgumentExplicit */ true, isUnpackedTuple));
         }
         return types_1.UnknownType.create();
     }
@@ -5032,17 +5025,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         else if (positionalArgs.length === 0 && unpackedListArgs.length === 0) {
             // Handle the case where there are no positionals provided but there are keywords.
-            positionalIndexType =
-                tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)
-                    ? (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, []))
-                    : types_1.UnknownType.create();
+            positionalIndexType = makeTupleObject([]);
         }
         else {
             // Package up all of the positionals into a tuple.
-            const tupleEntries = [];
+            const tupleTypeArgs = [];
             positionalArgs.forEach((arg) => {
                 const typeResult = getTypeOfExpression(arg.valueExpression);
-                tupleEntries.push(typeResult.type);
+                tupleTypeArgs.push({ type: typeResult.type, isUnbounded: false });
                 if (typeResult.isIncomplete) {
                     isPositionalIndexTypeIncomplete = true;
                 }
@@ -5054,9 +5044,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     isPositionalIndexTypeIncomplete = true;
                 }
                 const iterableType = (_b = (_a = getTypeOfIterator(typeResult, /* isAsync */ false, arg.valueExpression)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
-                tupleEntries.push(iterableType);
+                tupleTypeArgs.push({ type: iterableType, isUnbounded: true });
             });
-            positionalIndexType = makeTupleObject(tupleEntries, unpackedListArgs.length > 0);
+            positionalIndexType = makeTupleObject(tupleTypeArgs);
         }
         let argList = [
             {
@@ -5101,7 +5091,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // which type to use.
         if (keywordArgs.length === 0 && unpackedDictArgs.length === 0 && positionalArgs.length === 1) {
             useSpeculativeMode(node, () => {
-                callResult = validateCallArguments(node, argList, { type: itemMethodType });
+                callResult = validateCallArguments(node, argList, { type: itemMethodType }, 
+                /* typeVarContext */ undefined, 
+                /* skipUnknownArgCheck */ true);
                 if (callResult.argumentErrors) {
                     // If the object supports "__index__" magic method, convert
                     // the index to an int and try again.
@@ -5124,7 +5116,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             });
         }
-        callResult = validateCallArguments(node, argList, { type: itemMethodType });
+        callResult = validateCallArguments(node, argList, { type: itemMethodType }, 
+        /* typeVarContext */ undefined, 
+        /* skipUnknownArgCheck */ true);
         return {
             type: (_d = callResult.returnType) !== null && _d !== void 0 ? _d : types_1.UnknownType.create(),
             isIncomplete: !!callResult.isTypeIncomplete,
@@ -5144,7 +5138,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return undefined;
         }
         const slicedTypeArgs = tupleTypeArgs.slice(startValue, endValue);
-        return types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleType, slicedTypeArgs));
+        return makeTupleObject(slicedTypeArgs);
     }
     function getTupleSliceParameter(expression, defaultValue, tupleTypeArgs) {
         let value = defaultValue;
@@ -5412,8 +5406,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const entryTypeResults = node.expressions.map((expr, index) => getTypeOfExpression(expr, 
         /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(index < expectedTypes.length ? expectedTypes[index] : undefined, inferenceContext.isTypeIncomplete, inferenceContext.signatureTracker)));
         const isIncomplete = entryTypeResults.some((result) => result.isIncomplete);
-        const type = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, buildTupleTypesList(entryTypeResults), 
-        /* isTypeArgumentExplicit */ true));
+        const type = makeTupleObject(buildTupleTypesList(entryTypeResults));
         // Copy any expected type diag addenda for precision error reporting.
         let expectedTypeDiagAddendum;
         if (entryTypeResults.some((result) => result.expectedTypeDiagAddendum)) {
@@ -5429,10 +5422,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getTypeOfTupleInferred(node) {
         const entryTypeResults = node.expressions.map((expr) => getTypeOfExpression(expr));
         const isIncomplete = entryTypeResults.some((result) => result.isIncomplete);
-        if (!tupleClassType || !(0, types_1.isInstantiableClass)(tupleClassType)) {
-            return { type: types_1.UnknownType.create() };
-        }
-        const type = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, buildTupleTypesList(entryTypeResults)));
+        const type = makeTupleObject(buildTupleTypesList(entryTypeResults));
         if (isIncomplete) {
             if ((0, typeUtils_1.getContainerDepth)(type) > maxInferredContainerDepth) {
                 return { type: types_1.UnknownType.create() };
@@ -5889,10 +5879,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // If the bind-to type is a protocol, don't use the effective target class.
             // This pattern is used for mixins, where the mixin type is a protocol class
             // that is used to decorate the "self" or "cls" parameter.
+            let isProtocolClass = false;
             if (bindToType &&
                 types_1.ClassType.isProtocolClass(bindToType) &&
                 effectiveTargetClass &&
                 !types_1.ClassType.isSameGenericClass(bindToType, effectiveTargetClass)) {
+                isProtocolClass = true;
                 effectiveTargetClass = undefined;
             }
             const lookupResults = bindToType
@@ -5901,6 +5893,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             let resultType;
             if (lookupResults && (0, types_1.isInstantiableClass)(lookupResults.classType)) {
                 resultType = lookupResults.classType;
+                if (isProtocolClass) {
+                    // If the bindToType is a protocol class, set the "include subclasses" flag
+                    // so we don't enforce that called methods are implemented within the protocol.
+                    resultType = types_1.ClassType.cloneIncludeSubclasses(resultType);
+                }
             }
             else if (effectiveTargetClass &&
                 !(0, types_1.isAnyOrUnknown)(effectiveTargetClass) &&
@@ -6416,7 +6413,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (callTypeResult.type.specialForm) {
             const exprNode = errorNode.nodeType === 9 /* ParseNodeType.Call */ ? errorNode.leftExpression : errorNode;
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.objectNotCallable().format({
-                type: printType(callTypeResult.type, { expandTypeAlias: true }),
+                type: printType(callTypeResult.type.specialForm, { expandTypeAlias: true }),
             }), exprNode);
             return { returnType: types_1.UnknownType.create(), argumentErrors: true, overloadsUsedForCall };
         }
@@ -6906,7 +6903,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     argumentCategory: 1 /* ArgumentCategory.UnpackedList */,
                                     valueExpression: undefined,
                                     typeResult: {
-                                        type: (0, typeUtils_1.specializeTupleClass)(combinedArgType, [tupleTypeArg]),
+                                        type: makeTupleObject([tupleTypeArg]),
                                     },
                                 });
                             }
@@ -6934,7 +6931,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // validation is left to the caller.
     // This logic is based on PEP 3102: https://www.python.org/dev/peps/pep-3102/
     function matchFunctionArgumentsToParameters(errorNode, argList, typeResult, overloadIndex) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         const paramDetails = (0, parameterUtils_1.getParameterListDetails)(typeResult.type);
         let argIndex = 0;
         let matchedUnpackedListOfUnknownLength = false;
@@ -7162,10 +7159,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     listElementType = undefined;
                 }
                 else {
-                    listElementType =
-                        (_e = (_d = getTypeOfIterator({ type: argType, isIncomplete: argTypeResult.isIncomplete }, 
-                        /* isAsync */ false, errorNode, 
-                        /* emitNotIterableError */ false)) === null || _d === void 0 ? void 0 : _d.type) !== null && _e !== void 0 ? _e : types_1.UnknownType.create();
+                    listElementType = (_d = getTypeOfIterator({ type: argType, isIncomplete: argTypeResult.isIncomplete }, 
+                    /* isAsync */ false, errorNode, 
+                    /* emitNotIterableError */ false)) === null || _d === void 0 ? void 0 : _d.type;
                     if (paramDetails.params[paramIndex].param.category !== 1 /* ParameterCategory.ArgsList */) {
                         matchedUnpackedListOfUnknownLength = true;
                     }
@@ -7175,8 +7171,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         argumentCategory: 0 /* ArgumentCategory.Simple */,
                         typeResult: { type: listElementType, isIncomplete: argTypeResult.isIncomplete },
                     }
-                    : undefined;
-                if (funcArg && argTypeResult.isIncomplete) {
+                    : { ...argList[argIndex] };
+                if (argTypeResult.isIncomplete) {
                     isTypeIncomplete = true;
                 }
                 // It's not allowed to use unpacked arguments with a variadic *args
@@ -7197,7 +7193,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             paramType,
                             requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                             argument: funcArg,
-                            errorNode: (_f = argList[argIndex].valueExpression) !== null && _f !== void 0 ? _f : errorNode,
+                            errorNode: (_e = argList[argIndex].valueExpression) !== null && _e !== void 0 ? _e : errorNode,
                             paramName,
                             isParamNameSynthesized: paramDetails.params[paramIndex].param.isNameSynthesized,
                             mapsToVarArgList: isParamVariadic && remainingArgCount > remainingParamCount,
@@ -7501,7 +7497,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     paramType,
                                     requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                                     argument: argList[argIndex],
-                                    errorNode: (_g = argList[argIndex].valueExpression) !== null && _g !== void 0 ? _g : errorNode,
+                                    errorNode: (_f = argList[argIndex].valueExpression) !== null && _f !== void 0 ? _f : errorNode,
                                     paramName: paramNameValue,
                                 });
                                 trySetActive(argList[argIndex], paramDetails.params[paramInfoIndex].param);
@@ -7517,7 +7513,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 paramType,
                                 requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                                 argument: argList[argIndex],
-                                errorNode: (_h = argList[argIndex].valueExpression) !== null && _h !== void 0 ? _h : errorNode,
+                                errorNode: (_g = argList[argIndex].valueExpression) !== null && _g !== void 0 ? _g : errorNode,
                                 paramName: paramNameValue,
                             });
                             // Remember that this parameter has already received a value.
@@ -7567,7 +7563,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     requiresTypeVarMatching: false,
                                     argument: argList[argIndex],
                                     argType: (0, types_1.isParamSpec)(argType) ? undefined : types_1.AnyType.create(),
-                                    errorNode: (_j = argList[argIndex].valueExpression) !== null && _j !== void 0 ? _j : errorNode,
+                                    errorNode: (_h = argList[argIndex].valueExpression) !== null && _h !== void 0 ? _h : errorNode,
                                 });
                             }
                         }
@@ -7675,61 +7671,57 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const paramType = paramDetails.params[paramDetails.argsIndex].type;
                 const variadicArgs = validateArgTypeParams.filter((argParam) => argParam.mapsToVarArgList);
                 if ((0, types_1.isVariadicTypeVar)(paramType) && !paramType.isVariadicInUnion) {
-                    if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
-                        const tupleTypeArgs = variadicArgs.map((argParam) => {
-                            var _a;
-                            const argType = getTypeOfArgument(argParam.argument).type;
-                            const containsVariadicTypeVar = (0, types_1.isUnpackedVariadicTypeVar)(argType) ||
-                                ((0, types_1.isClassInstance)(argType) &&
-                                    (0, typeUtils_1.isTupleClass)(argType) &&
-                                    argType.tupleTypeArguments &&
-                                    argType.tupleTypeArguments.length === 1 &&
-                                    (0, types_1.isUnpackedVariadicTypeVar)(argType.tupleTypeArguments[0].type));
-                            if (containsVariadicTypeVar &&
-                                argParam.argument.argumentCategory !== 1 /* ArgumentCategory.UnpackedList */ &&
-                                !argParam.mapsToVarArgList) {
-                                if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.typeVarTupleMustBeUnpacked(), (_a = argParam.argument.valueExpression) !== null && _a !== void 0 ? _a : errorNode);
-                                }
-                                reportedArgError = true;
+                    const tupleTypeArgs = variadicArgs.map((argParam) => {
+                        var _a;
+                        const argType = getTypeOfArgument(argParam.argument).type;
+                        const containsVariadicTypeVar = (0, types_1.isUnpackedVariadicTypeVar)(argType) ||
+                            ((0, types_1.isClassInstance)(argType) &&
+                                (0, typeUtils_1.isTupleClass)(argType) &&
+                                argType.tupleTypeArguments &&
+                                argType.tupleTypeArguments.length === 1 &&
+                                (0, types_1.isUnpackedVariadicTypeVar)(argType.tupleTypeArguments[0].type));
+                        if (containsVariadicTypeVar &&
+                            argParam.argument.argumentCategory !== 1 /* ArgumentCategory.UnpackedList */ &&
+                            !argParam.mapsToVarArgList) {
+                            if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.typeVarTupleMustBeUnpacked(), (_a = argParam.argument.valueExpression) !== null && _a !== void 0 ? _a : errorNode);
                             }
-                            return {
-                                type: argType,
-                                isUnbounded: argParam.argument.argumentCategory === 1 /* ArgumentCategory.UnpackedList */,
-                            };
-                        });
-                        let specializedTuple;
-                        if (tupleTypeArgs.length === 1 &&
-                            !tupleTypeArgs[0].isUnbounded &&
-                            ((0, types_1.isUnpackedClass)(tupleTypeArgs[0].type) || (0, types_1.isVariadicTypeVar)(tupleTypeArgs[0].type))) {
-                            // If there is a single unpacked tuple or unpacked variadic type variable
-                            // (including an unpacked TypeVarTuple union) within this tuple,
-                            // simplify the type.
-                            specializedTuple = tupleTypeArgs[0].type;
-                        }
-                        else {
-                            specializedTuple = types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, tupleTypeArgs, 
-                            /* isTypeArgumentExplicit */ true, 
-                            /* isUnpackedTuple */ true));
+                            reportedArgError = true;
                         }
-                        const combinedArg = {
-                            paramCategory: 1 /* ParameterCategory.ArgsList */,
-                            paramType,
-                            requiresTypeVarMatching: true,
-                            argument: {
-                                argumentCategory: 0 /* ArgumentCategory.Simple */,
-                                typeResult: { type: specializedTuple },
-                            },
-                            errorNode,
-                            paramName: paramDetails.params[paramDetails.argsIndex].param.name,
-                            isParamNameSynthesized: paramDetails.params[paramDetails.argsIndex].param.isNameSynthesized,
-                            mapsToVarArgList: true,
+                        return {
+                            type: argType,
+                            isUnbounded: argParam.argument.argumentCategory === 1 /* ArgumentCategory.UnpackedList */,
                         };
-                        validateArgTypeParams = [
-                            ...validateArgTypeParams.filter((argParam) => !argParam.mapsToVarArgList),
-                            combinedArg,
-                        ];
+                    });
+                    let specializedTuple;
+                    if (tupleTypeArgs.length === 1 &&
+                        !tupleTypeArgs[0].isUnbounded &&
+                        ((0, types_1.isUnpackedClass)(tupleTypeArgs[0].type) || (0, types_1.isVariadicTypeVar)(tupleTypeArgs[0].type))) {
+                        // If there is a single unpacked tuple or unpacked variadic type variable
+                        // (including an unpacked TypeVarTuple union) within this tuple,
+                        // simplify the type.
+                        specializedTuple = tupleTypeArgs[0].type;
                     }
+                    else {
+                        specializedTuple = makeTupleObject(tupleTypeArgs, /* isUnpackedTuple */ true);
+                    }
+                    const combinedArg = {
+                        paramCategory: 1 /* ParameterCategory.ArgsList */,
+                        paramType,
+                        requiresTypeVarMatching: true,
+                        argument: {
+                            argumentCategory: 0 /* ArgumentCategory.Simple */,
+                            typeResult: { type: specializedTuple },
+                        },
+                        errorNode,
+                        paramName: paramDetails.params[paramDetails.argsIndex].param.name,
+                        isParamNameSynthesized: paramDetails.params[paramDetails.argsIndex].param.isNameSynthesized,
+                        mapsToVarArgList: true,
+                    };
+                    validateArgTypeParams = [
+                        ...validateArgTypeParams.filter((argParam) => !argParam.mapsToVarArgList),
+                        combinedArg,
+                    ];
                 }
             }
         }
@@ -8067,7 +8059,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let specializedReturnType = (0, typeUtils_1.applySolvedTypeVars)(returnType, typeVarContext, {
             unknownIfNotFound,
             unknownExemptTypeVars: getUnknownExemptTypeVarsForReturnType(type, returnType),
-            useUnknownOverDefault: skipUnknownArgCheck,
             eliminateUnsolvedInUnions,
             applyInScopePlaceholders: true,
         });
@@ -8913,7 +8904,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             typeParamsExpr.expressions.map((expr) => {
                 let entryType = getTypeOfExpression(expr, 128 /* EvaluatorFlags.ExpectingInstantiableType */ | 4096 /* EvaluatorFlags.AllowTypeVarsWithoutScopeId */).type;
                 if ((0, types_1.isTypeVar)(entryType)) {
-                    if (entryType.scopeId) {
+                    if (entryType.scopeId || entryType.isVariadicUnpacked) {
                         isTypeParamListValid = false;
                     }
                     else {
@@ -10048,7 +10039,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (!expectedValueOrElementType || !(0, typeUtils_1.containsLiteralType)(expectedValueOrElementType)) {
                 valueType = stripLiteralValue(valueType);
             }
-            type = makeTupleObject([keyType, valueType]);
+            type = makeTupleObject([
+                { type: keyType, isUnbounded: false },
+                { type: valueType, isUnbounded: false },
+            ]);
         }
         else if (node.expression.nodeType === 16 /* ParseNodeType.DictionaryExpandEntry */) {
             // The parser should have reported an error in this case because it's not allowed.
@@ -10916,7 +10910,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (isPep695Syntax || isPep695TypeVarType) {
             const typeAliasTypeClass = getTypingType(errorNode, 'TypeAliasType');
             if (typeAliasTypeClass && (0, types_1.isInstantiableClass)(typeAliasTypeClass)) {
-                typeAlias = types_1.TypeBase.cloneAsSpecialForm(typeAlias, typeAliasTypeClass);
+                typeAlias = types_1.TypeBase.cloneAsSpecialForm(typeAlias, types_1.ClassType.cloneAsInstance(typeAliasTypeClass));
             }
         }
         return typeAlias;
@@ -11168,9 +11162,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 // If this is an enum, transform the type as required.
                 rightHandType = srcType;
-                if (node.leftExpression.nodeType === 38 /* ParseNodeType.Name */ && !node.typeAnnotationComment) {
+                let targetName;
+                if (node.leftExpression.nodeType === 38 /* ParseNodeType.Name */) {
+                    targetName = node.leftExpression;
+                }
+                else if (node.leftExpression.nodeType === 54 /* ParseNodeType.TypeAnnotation */ &&
+                    node.leftExpression.valueExpression.nodeType === 38 /* ParseNodeType.Name */) {
+                    targetName = node.leftExpression.valueExpression;
+                }
+                if (targetName) {
                     rightHandType =
-                        (_a = (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, node, node.leftExpression, () => rightHandType)) !== null && _a !== void 0 ? _a : rightHandType;
+                        (_a = (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, node, targetName, () => {
+                            return { assignedType: rightHandType };
+                        })) !== null && _a !== void 0 ? _a : rightHandType;
                 }
                 if (typeAliasNameNode) {
                     // If this was a speculative type alias, it becomes a real type alias
@@ -12239,7 +12243,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // In case this is an enum class and a method wrapped in an enum.member.
         decoratedType =
-            (_a = (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, node, node.name, () => decoratedType)) !== null && _a !== void 0 ? _a : decoratedType;
+            (_a = (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, node, node.name, () => {
+                return { assignedType: decoratedType };
+            })) !== null && _a !== void 0 ? _a : decoratedType;
         // See if there are any overloads provided by previous function declarations.
         if ((0, types_1.isFunction)(decoratedType)) {
             decoratedType.details.deprecatedMessage = functionType.details.deprecatedMessage;
@@ -12750,11 +12756,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if ((0, types_1.isUnpackedClass)(type)) {
                     return types_1.ClassType.cloneForUnpacked(type, /* isUnpackedTuple */ false);
                 }
-                if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
-                    return types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, [{ type, isUnbounded: !(0, types_1.isVariadicTypeVar)(type) }], 
-                    /* isTypeArgumentExplicit */ true));
-                }
-                return types_1.UnknownType.create();
+                return makeTupleObject([{ type, isUnbounded: !(0, types_1.isVariadicTypeVar)(type) }]);
             }
             case 2 /* ParameterCategory.KwargsDict */: {
                 // Leave a ParamSpec alone.
@@ -14826,7 +14828,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             const variableNode = (_c = ParseTreeUtils.getParentNodeOfType(declaration.node, 3 /* ParseNodeType.Assignment */)) !== null && _c !== void 0 ? _c : ParseTreeUtils.getParentNodeOfType(declaration.node, 54 /* ParseNodeType.TypeAnnotation */);
                             if (variableNode) {
                                 declaredType =
-                                    (_d = (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, variableNode, declaration.node, () => declaredType)) !== null && _d !== void 0 ? _d : declaredType;
+                                    (_d = (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, variableNode, declaration.node, () => {
+                                        return { declaredType };
+                                    })) !== null && _d !== void 0 ? _d : declaredType;
                             }
                         }
                         if ((0, types_1.isClassInstance)(declaredType) && types_1.ClassType.isBuiltIn(declaredType, 'TypeAlias')) {
@@ -15081,9 +15085,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         var _a, _b;
                         (0, debug_1.assert)(resolvedDecl.inferredTypeSource !== undefined);
                         const inferredTypeSource = resolvedDecl.inferredTypeSource;
-                        return ((_b = (_a = evaluateTypeForSubnode(inferredTypeSource, () => {
-                            evaluateTypesForStatement(inferredTypeSource);
-                        })) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create());
+                        return {
+                            assignedType: (_b = (_a = evaluateTypeForSubnode(inferredTypeSource, () => {
+                                evaluateTypesForStatement(inferredTypeSource);
+                            })) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create(),
+                        };
                     });
                     if (enumMemberType) {
                         inferredType = enumMemberType;
@@ -16039,26 +16045,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const destUnboundedOrVariadicIndex = destTypeArgs.findIndex((t) => t.isUnbounded || (0, types_1.isVariadicTypeVar)(t.type));
         const srcUnboundedIndex = srcTypeArgs.findIndex((t) => t.isUnbounded);
         const srcVariadicIndex = srcTypeArgs.findIndex((t) => (0, types_1.isVariadicTypeVar)(t.type));
-        let isSrcVariadicAny = false;
-        // If the src contains an unbounded type but the dest does not, it's incompatible.
-        if (srcUnboundedIndex >= 0 && destUnboundedOrVariadicIndex < 0) {
-            // Unless the source contains an [Any, ...].
+        if (srcUnboundedIndex >= 0) {
             if ((0, types_1.isAnyOrUnknown)(srcTypeArgs[srcUnboundedIndex].type)) {
-                isSrcVariadicAny = true;
+                // If the source contains an unbounded Any, expand it to match the dest length.
+                const typeToReplicate = srcTypeArgs.length > 0 ? srcTypeArgs[srcUnboundedIndex].type : types_1.AnyType.create();
+                while (srcTypeArgs.length < destTypeArgs.length) {
+                    srcTypeArgs.splice(srcUnboundedIndex, 0, { type: typeToReplicate, isUnbounded: true });
+                }
+                if (srcTypeArgs.length > destTypeArgs.length) {
+                    srcTypeArgs.splice(srcUnboundedIndex, 1);
+                }
             }
-            else {
+            else if (destUnboundedOrVariadicIndex < 0) {
+                // If the source contains an unbounded type but the dest does not, it's incompatible.
                 return false;
             }
         }
-        if (srcUnboundedIndex >= 0) {
-            // The source is unbounded, so expand the unbounded argument to try
-            // to make the source and dest arg counts match.
-            const typeToReplicate = srcTypeArgs.length > 0 ? srcTypeArgs[srcUnboundedIndex].type : types_1.AnyType.create();
-            while (srcTypeArgs.length < destTypeArgs.length) {
-                srcTypeArgs.splice(srcUnboundedIndex, 0, { type: typeToReplicate, isUnbounded: true });
-            }
-            if (isSrcVariadicAny && srcTypeArgs.length > destTypeArgs.length) {
-                srcTypeArgs.splice(srcUnboundedIndex, 1);
+        // If the dest contains an unbounded Any, expand it to match the source length.
+        if (destUnboundedOrVariadicIndex >= 0 &&
+            destTypeArgs[destUnboundedOrVariadicIndex].isUnbounded &&
+            (0, types_1.isAnyOrUnknown)(destTypeArgs[destUnboundedOrVariadicIndex].type)) {
+            while (destTypeArgs.length < srcTypeArgs.length) {
+                destTypeArgs.splice(destUnboundedOrVariadicIndex, 0, destTypeArgs[destUnboundedOrVariadicIndex]);
             }
         }
         // Remove any optional parameters from the end of the two lists until the lengths match.
@@ -16068,23 +16076,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         while (destTypeArgs.length > srcTypeArgs.length && destTypeArgs[destTypeArgs.length - 1].isOptional) {
             destTypeArgs.splice(destTypeArgs.length - 1, 1);
         }
-        if (srcVariadicIndex >= 0) {
+        // If we're doing reverse type mappings and the source contains a variadic
+        // TypeVar, we need to adjust the dest so the reverse type mapping assignment
+        // can be performed.
+        if ((flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) !== 0) {
             const destArgsToCapture = destTypeArgs.length - srcTypeArgs.length + 1;
-            // If we're doing reverse type mappings and the source contains a variadic
-            // TypeVar, we need to adjust the dest so the reverse type mapping assignment
-            // can be performed.
-            if (destArgsToCapture >= 0 && (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) !== 0) {
+            if (srcVariadicIndex >= 0 && destArgsToCapture >= 0) {
                 // If the only removed arg from the dest type args is itself a variadic,
                 // don't bother adjusting it.
                 const skipAdjustment = destArgsToCapture === 1 && (0, types_1.isVariadicTypeVar)(destTypeArgs[srcVariadicIndex].type);
                 if (!skipAdjustment && tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
                     const removedArgs = destTypeArgs.splice(srcVariadicIndex, destArgsToCapture);
                     // Package up the remaining type arguments into a tuple object.
-                    const variadicTuple = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, removedArgs.map((typeArg) => {
-                        return { type: typeArg.type, isUnbounded: typeArg.isUnbounded };
+                    const variadicTuple = makeTupleObject(removedArgs.map((typeArg) => {
+                        return {
+                            type: typeArg.type,
+                            isUnbounded: typeArg.isUnbounded,
+                            isOptional: typeArg.isOptional,
+                        };
                     }), 
-                    /* isTypeArgumentExplicit */ true, 
-                    /* isUnpackedTuple */ true));
+                    /* isUnpackedTuple */ true);
                     destTypeArgs.splice(srcVariadicIndex, 0, {
                         type: variadicTuple,
                         isUnbounded: false,
@@ -16101,11 +16112,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
                         const removedArgs = srcTypeArgs.splice(destUnboundedOrVariadicIndex, srcArgsToCapture);
                         // Package up the remaining type arguments into a tuple object.
-                        const variadicTuple = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, removedArgs.map((typeArg) => {
-                            return { type: typeArg.type, isUnbounded: typeArg.isUnbounded };
+                        const variadicTuple = makeTupleObject(removedArgs.map((typeArg) => {
+                            return {
+                                type: typeArg.type,
+                                isUnbounded: typeArg.isUnbounded,
+                                isOptional: typeArg.isOptional,
+                            };
                         }), 
-                        /* isTypeArgumentExplicit */ true, 
-                        /* isUnpackedTuple */ true));
+                        /* isUnpackedTuple */ true);
                         srcTypeArgs.splice(destUnboundedOrVariadicIndex, 0, {
                             type: variadicTuple,
                             isUnbounded: false,
@@ -16113,18 +16127,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 else {
-                    const removedArgTypes = srcTypeArgs
-                        .splice(destUnboundedOrVariadicIndex, srcArgsToCapture)
-                        .map((t) => {
-                        if ((0, types_1.isTypeVar)(t.type) && (0, types_1.isUnpackedVariadicTypeVar)(t.type) && !t.type.isVariadicInUnion) {
-                            return types_1.TypeVarType.cloneForUnpacked(t.type, /* isInUnion */ true);
-                        }
-                        return t.type;
-                    });
-                    srcTypeArgs.splice(destUnboundedOrVariadicIndex, 0, {
-                        type: removedArgTypes.length > 0 ? (0, types_1.combineTypes)(removedArgTypes) : types_1.AnyType.create(),
-                        isUnbounded: false,
-                    });
+                    // If possible, package up the source entries that correspond to
+                    // the dest unbounded tuple. This isn't possible if the source contains
+                    // an unbounded tuple outside of this range.
+                    if (srcUnboundedIndex < 0 ||
+                        (srcUnboundedIndex >= destUnboundedOrVariadicIndex &&
+                            srcUnboundedIndex < destUnboundedOrVariadicIndex + srcArgsToCapture)) {
+                        const removedArgTypes = srcTypeArgs
+                            .splice(destUnboundedOrVariadicIndex, srcArgsToCapture)
+                            .map((t) => {
+                            if ((0, types_1.isTypeVar)(t.type) &&
+                                (0, types_1.isUnpackedVariadicTypeVar)(t.type) &&
+                                !t.type.isVariadicInUnion) {
+                                return types_1.TypeVarType.cloneForUnpacked(t.type, /* isInUnion */ true);
+                            }
+                            return t.type;
+                        });
+                        srcTypeArgs.splice(destUnboundedOrVariadicIndex, 0, {
+                            type: removedArgTypes.length > 0 ? (0, types_1.combineTypes)(removedArgTypes) : types_1.AnyType.create(),
+                            isUnbounded: false,
+                        });
+                    }
                 }
             }
         }
@@ -16148,16 +16171,32 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         else {
-            if (srcTypeArgs.find((t) => t.isUnbounded)) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.tupleSizeIndeterminate().format({
-                    expected: destTypeArgs.length,
-                }));
+            const isDestIndeterminate = destTypeArgs.some((t) => t.isUnbounded || (0, types_1.isVariadicTypeVar)(t.type));
+            if (srcTypeArgs.some((t) => t.isUnbounded || (0, types_1.isVariadicTypeVar)(t.type))) {
+                if (isDestIndeterminate) {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.tupleSizeIndeterminateSrcDest().format({
+                        expected: destTypeArgs.length - 1,
+                    }));
+                }
+                else {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.tupleSizeIndeterminateSrc().format({
+                        expected: destTypeArgs.length,
+                    }));
+                }
             }
             else {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.tupleSizeMismatch().format({
-                    expected: destTypeArgs.length,
-                    received: srcTypeArgs.length,
-                }));
+                if (isDestIndeterminate) {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.tupleSizeMismatchIndeterminateDest().format({
+                        expected: destTypeArgs.length - 1,
+                        received: srcTypeArgs.length,
+                    }));
+                }
+                else {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.tupleSizeMismatch().format({
+                        expected: destTypeArgs.length,
+                        received: srcTypeArgs.length,
+                    }));
+                }
             }
             return false;
         }
@@ -16248,6 +16287,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const typeParam = destType.details.typeParameters[i];
                 const variance = types_1.TypeVarType.getVariance(typeParam);
                 (0, constraintSolver_1.updateTypeVarType)(evaluatorInterface, destTypeVarContext, typeParam, variance !== 4 /* Variance.Contravariant */ ? typeArgType : undefined, variance !== 3 /* Variance.Covariant */ ? typeArgType : undefined, 
+                /* tupleTypes */ curSrcType.tupleTypeArguments, 
                 /* forceRetainLiterals */ true);
             }
         }
@@ -17010,7 +17050,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return false;
                 });
                 if (destTypeIndex >= 0) {
-                    if (assignType(remainingDestSubtypes[destTypeIndex], srcSubtype, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+                    if (assignType(remainingDestSubtypes[destTypeIndex], srcSubtype, 
+                    /* diag */ undefined, destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
                         // Note that we have matched at least one subtype indicating
                         // there is at least some overlap.
                         matchedSomeSubtypes = true;
@@ -17459,15 +17500,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         });
         if (srcTupleTypes.length !== 1 || !(0, types_1.isVariadicTypeVar)(srcTupleTypes[0].type)) {
-            let srcPositionalsType;
-            if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
-                srcPositionalsType = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, srcTupleTypes, 
-                /* isTypeArgumentExplicit */ true, 
-                /* isUnpackedTuple */ true));
-            }
-            else {
-                srcPositionalsType = types_1.UnknownType.create();
-            }
+            const srcPositionalsType = makeTupleObject(srcTupleTypes, /* isUnpackedTuple */ true);
             // Snip out the portion of the source positionals that map to the variadic
             // dest parameter and replace it with a single parameter that is typed as a
             // tuple containing the individual types of the replaced parameters.
@@ -17675,15 +17708,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             !types_1.FunctionType.shouldSkipArgsKwargsCompatibilityCheck(destType)) {
             let destArgsType = destParamDetails.params[destParamDetails.argsIndex].type;
             let srcArgsType = srcParamDetails.params[srcParamDetails.argsIndex].type;
-            if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
-                if (!(0, types_1.isUnpacked)(destArgsType)) {
-                    destArgsType = types_1.ClassType.cloneForUnpacked(types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, [{ type: destArgsType, isUnbounded: true }], 
-                    /* isTypeArgumentExplicit */ true)));
-                }
-                if (!(0, types_1.isUnpacked)(srcArgsType)) {
-                    srcArgsType = types_1.ClassType.cloneForUnpacked(types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, [{ type: srcArgsType, isUnbounded: true }], 
-                    /* isTypeArgumentExplicit */ true)));
-                }
+            if (!(0, types_1.isUnpacked)(destArgsType)) {
+                destArgsType = makeTupleObject([{ type: destArgsType, isUnbounded: true }], /* isUnpackedTuple */ true);
+            }
+            if (!(0, types_1.isUnpacked)(srcArgsType)) {
+                srcArgsType = makeTupleObject([{ type: srcArgsType, isUnbounded: true }], /* isUnpackedTuple */ true);
             }
             if (!assignFunctionParameter(destArgsType, srcArgsType, destParamDetails.params[destParamDetails.argsIndex].index, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
                 canAssign = false;
@@ -18012,6 +18041,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // we may be able to narrow the type based on the assignment.
     function narrowTypeBasedOnAssignment(node, declaredType, assignedType) {
         const narrowedType = (0, typeUtils_1.mapSubtypes)(assignedType, (assignedSubtype) => {
+            // Handle the special case where the assigned type is a literal type.
+            // Some types include very large unions of literal types, and we don't
+            // want to use an n^2 loop to compare them.
+            if ((0, types_1.isClass)(assignedSubtype) && (0, typeUtils_1.isLiteralType)(assignedSubtype)) {
+                if ((0, types_1.isUnion)(declaredType) && types_1.UnionType.containsType(declaredType, assignedSubtype)) {
+                    return assignedSubtype;
+                }
+            }
             const narrowedSubtype = (0, typeUtils_1.mapSubtypes)(declaredType, (declaredSubtype) => {
                 // We can't narrow "Any".
                 if ((0, types_1.isAnyOrUnknown)(declaredSubtype)) {