@zzzen/pyright-internal 1.2.0-dev.20240121 → 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);
@@ -2188,7 +2192,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (expectedTypeDiagAddendum) {
                     diagAddendum = expectedTypeDiagAddendum;
                 }
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAssignmentMismatch().format(printSrcDestTypes(type, declaredType)) +
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAssignmentType, localize_1.LocMessage.typeAssignmentMismatch().format(printSrcDestTypes(type, declaredType)) +
                     diagAddendum.getString(), srcExpression !== null && srcExpression !== void 0 ? srcExpression : nameNode, (_c = (_b = diagAddendum.getEffectiveTextRange()) !== null && _b !== void 0 ? _b : srcExpression) !== null && _c !== void 0 ? _c : nameNode);
                 // Replace the assigned type with the (unnarrowed) declared type.
                 destType = declaredType;
@@ -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,
                     }));
                 }
@@ -2441,7 +2446,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         });
         if (!diagAddendum.isEmpty()) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, (target.nodeType === 31 /* ParseNodeType.List */
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAssignmentType, (target.nodeType === 31 /* ParseNodeType.List */
                 ? localize_1.LocMessage.listAssignmentMismatch()
                 : localize_1.LocMessage.tupleAssignmentMismatch()).format({
                 type: printType(type),
@@ -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();
                 }
@@ -3018,7 +3020,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             if (effectiveTypeInfo.includesIllegalTypeAliasDecl ||
                                 !types_1.TypeBase.isInstantiable(type) ||
                                 (flags & 2 /* EvaluatorFlags.DoNotSpecialize */) !== 0) {
-                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAnnotationVariable(), node);
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAnnotationVariable(), node);
                                 type = 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();
@@ -3655,7 +3656,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     if (!type) {
                         if (!isIncomplete) {
-                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.moduleUnknownMember().format({
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAttributeAccessIssue, localize_1.LocMessage.moduleUnknownMember().format({
                                 memberName,
                                 moduleName: baseType.moduleName,
                             }), node.memberName);
@@ -3741,7 +3742,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 const rule = isFunctionRule
                     ? diagnosticRules_1.DiagnosticRule.reportFunctionMemberAccess
-                    : diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues;
+                    : diagnosticRules_1.DiagnosticRule.reportAttributeAccessIssue;
                 addDiagnostic(rule, diagMessage.format({ name: memberName, type: printType(baseType) }) + diag.getString(), node.memberName, (_a = diag.getEffectiveTextRange()) !== null && _a !== void 0 ? _a : node.memberName);
             }
             // If this is member access on a function, use "Any" so if the
@@ -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;
     }
@@ -4732,7 +4727,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const itemMethodType = getBoundMagicMethod(concreteSubtype, getIndexAccessMagicMethodName(usage));
                     if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
                         // If the class doesn't derive from Generic, a type argument should not be allowed.
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeArgsExpectingNone().format({
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsExpectingNone().format({
                             name: printType(types_1.ClassType.cloneAsInstance(concreteSubtype)),
                         }), node);
                     }
@@ -4800,7 +4795,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return concreteSubtype;
                 }
                 if (concreteSubtype.typeArguments) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.classAlreadySpecialized().format({
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.classAlreadySpecialized().format({
                         type: printType((0, typeUtils_1.convertToInstance)(concreteSubtype), { expandTypeAlias: true }),
                     }), node.baseExpression);
                     return concreteSubtype;
@@ -4837,7 +4832,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return types_1.UnknownType.create();
             }
             if (!isIncomplete) {
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeNotSubscriptable().format({ type: printType(concreteSubtype) }), node.baseExpression);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIndexIssue, localize_1.LocMessage.typeNotSubscriptable().format({ type: printType(concreteSubtype) }), node.baseExpression);
             }
             return types_1.UnknownType.create();
         });
@@ -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();
     }
@@ -4968,7 +4961,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const magicMethodName = getIndexAccessMagicMethodName(usage);
         const itemMethodType = getBoundMagicMethod(baseType, magicMethodName, selfType);
         if (!itemMethodType) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.methodNotDefinedOnType().format({
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIndexIssue, localize_1.LocMessage.methodNotDefinedOnType().format({
                 name: magicMethodName,
                 type: printType(baseType),
             }), node.baseExpression);
@@ -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;
@@ -5324,7 +5318,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // a zero-length tuple.
             const diag = new diagnostic_1.DiagnosticAddendum();
             diag.addMessage(localize_1.LocAddendum.useTupleInstead());
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.tupleInAnnotation() + diag.getString(), node);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.tupleInAnnotation() + diag.getString(), node);
             return { type: types_1.UnknownType.create() };
         }
         if ((flags & 128 /* EvaluatorFlags.ExpectingInstantiableType */) !== 0 &&
@@ -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() };
@@ -5493,7 +5483,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             node.leftExpression.value === 'type') {
             const diag = new diagnostic_1.DiagnosticAddendum();
             diag.addMessage(localize_1.LocAddendum.useTypeInstead());
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeCallNotAllowed() + diag.getString(), node);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeCallNotAllowed() + diag.getString(), node);
         }
         // Handle immediate calls of lambdas specially.
         if (node.leftExpression.nodeType === 30 /* ParseNodeType.Lambda */) {
@@ -5593,7 +5583,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAnnotationCall(), node);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAnnotationCall(), node);
             typeResult = { type: types_1.UnknownType.create() };
         }
         return typeResult;
@@ -5662,7 +5652,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const assertedType = (0, typeUtils_1.convertToInstance)(getTypeOfArgumentExpectingType(node.arguments[1]).type);
         if (!(0, types_1.isTypeSame)(assertedType, arg0TypeResult.type, { treatAnySameAsUnknown: true, ignorePseudoGeneric: true })) {
             const srcDestTypes = printSrcDestTypes(arg0TypeResult.type, assertedType, { expandTypeAlias: true });
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.assertTypeTypeMismatch().format({
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAssertTypeFailure, localize_1.LocMessage.assertTypeTypeMismatch().format({
                 expected: srcDestTypes.destType,
                 received: srcDestTypes.sourceType,
             }), node.arguments[0].valueExpression);
@@ -5777,7 +5767,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             targetClassType = getTypeOfExpression(node.arguments[0].valueExpression).type;
             const concreteTargetClassType = makeTopLevelTypeVarsConcrete(targetClassType);
             if (!(0, types_1.isAnyOrUnknown)(concreteTargetClassType) && !(0, types_1.isInstantiableClass)(concreteTargetClassType)) {
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.superCallFirstArg().format({ type: printType(targetClassType) }), node.arguments[0].valueExpression);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportArgumentType, localize_1.LocMessage.superCallFirstArg().format({ type: printType(targetClassType) }), node.arguments[0].valueExpression);
             }
         }
         else {
@@ -5829,7 +5819,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 reportError = true;
             }
             if (reportError) {
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.superCallSecondArg().format({ type: printType(targetClassType) }), node.arguments[1].valueExpression);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportArgumentType, localize_1.LocMessage.superCallSecondArg().format({ type: printType(targetClassType) }), node.arguments[1].valueExpression);
                 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) &&
@@ -6264,7 +6261,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return typeString;
                 });
                 diagAddendum.addMessage(localize_1.LocAddendum.argumentTypes().format({ types: argTypes.join(', ') }));
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.noOverload().format({ name: functionName }) + diagAddendum.getString(), errorNode);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.noOverload().format({ name: functionName }) + diagAddendum.getString(), errorNode);
             }
             return { argumentErrors: true, isTypeIncomplete, overloadsUsedForCall: [] };
         }
@@ -6284,7 +6281,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // was possible and emit a diagnostic that provides the most likely.
             if (emitNoOverloadFoundError) {
                 const functionName = bestMatch.overload.details.name || '<anonymous function>';
-                const diagnostic = addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.noOverload().format({ name: functionName }), errorNode);
+                const diagnostic = addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.noOverload().format({ name: functionName }), errorNode);
                 const overrideDecl = bestMatch.overload.details.declaration;
                 if (diagnostic && overrideDecl) {
                     diagnostic.addRelatedInfo(localize_1.LocAddendum.overloadIndex().format({ index: bestMatch.overloadIndex + 1 }), overrideDecl.uri, overrideDecl.range);
@@ -6415,8 +6412,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Special forms are not callable.
         if (callTypeResult.type.specialForm) {
             const exprNode = errorNode.nodeType === 9 /* ParseNodeType.Call */ ? errorNode.leftExpression : errorNode;
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.objectNotCallable().format({
-                type: printType(callTypeResult.type, { expandTypeAlias: true }),
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.objectNotCallable().format({
+                type: printType(callTypeResult.type.specialForm, { expandTypeAlias: true }),
             }), exprNode);
             return { returnType: types_1.UnknownType.create(), argumentErrors: true, overloadsUsedForCall };
         }
@@ -6495,7 +6492,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return validateCallArguments(errorNode, argList, { type: (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expandedCallType), isIncomplete: isCallTypeIncomplete }, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
             }
             case 7 /* TypeCategory.Module */: {
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.moduleNotCallable(), errorNode);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.moduleNotCallable(), errorNode);
                 return { argumentErrors: true };
             }
         }
@@ -6504,7 +6501,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function validateCallForFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext) {
         var _a;
         if (types_1.TypeBase.isInstantiable(expandedCallType)) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.callableNotInstantiable().format({
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.callableNotInstantiable().format({
                 type: printType(expandedCallType),
             }), errorNode);
             return { returnType: undefined, argumentErrors: true };
@@ -6671,7 +6668,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function validateCallForInstantiableClass(errorNode, argList, expandedCallType, unexpandedCallType, skipUnknownArgCheck, inferenceContext) {
         var _a, _b;
         if (expandedCallType.literalValue !== undefined) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.literalNotCallable(), errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.literalNotCallable(), errorNode);
             return { returnType: types_1.UnknownType.create(), argumentErrors: true };
         }
         if (types_1.ClassType.isBuiltIn(expandedCallType)) {
@@ -6679,7 +6676,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Handle a call to a metaclass explicitly.
             if ((0, typeUtils_1.isInstantiableMetaclass)(expandedCallType)) {
                 if (expandedCallType.typeArguments && expandedCallType.isTypeArgumentExplicit) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.objectNotCallable().format({
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.objectNotCallable().format({
                         type: printType(expandedCallType),
                     }), errorNode);
                     return { returnType: types_1.UnknownType.create(), argumentErrors: true };
@@ -6751,7 +6748,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return { returnType: createNewType(errorNode, argList) };
             }
             if (types_1.ClassType.isSpecialFormClass(expandedCallType)) {
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeNotIntantiable().format({ type: className }), errorNode);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.typeNotIntantiable().format({ type: className }), errorNode);
                 return { returnType: types_1.UnknownType.create(), argumentErrors: true };
             }
             if (className === 'TypedDict') {
@@ -6793,14 +6790,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                 });
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.instantiateAbstract().format({
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAbstractUsage, localize_1.LocMessage.instantiateAbstract().format({
                     type: expandedCallType.details.name,
                 }) + diagAddendum.getString(), errorNode);
             }
         }
         if (types_1.ClassType.isProtocolClass(expandedCallType) && !expandedCallType.includeSubclasses) {
             // If the class is a protocol, it can't be instantiated.
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.instantiateProtocol().format({
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAbstractUsage, localize_1.LocMessage.instantiateProtocol().format({
                 type: expandedCallType.details.name,
             }), errorNode);
         }
@@ -6848,7 +6845,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         /* selfType */ undefined, recursionCount);
         const callMethodType = callMethodResult === null || callMethodResult === void 0 ? void 0 : callMethodResult.type;
         if (!callMethodType) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.objectNotCallable().format({
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.objectNotCallable().format({
                 type: printType(expandedCallType),
             }), errorNode);
             return { returnType: types_1.UnknownType.create(), argumentErrors: true };
@@ -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;
@@ -7049,7 +7046,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (argIndex < positionalOnlyLimitIndex && argList[argIndex].name) {
                 const nameNode = argList[argIndex].name;
                 if (nameNode) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.argPositional(), nameNode);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.argPositional(), nameNode);
                     reportedArgError = true;
                 }
             }
@@ -7083,7 +7080,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     if (tooManyPositionals) {
                         if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, positionParamLimitIndex === 1
                                 ? localize_1.LocMessage.argPositionalExpectedOne()
                                 : localize_1.LocMessage.argPositionalExpectedCount().format({
                                     expected: positionParamLimitIndex,
@@ -7116,7 +7113,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         argTypeResult.type.paramSpecAccess === 'args' &&
                         paramDetails.params[paramIndex].param.category !== 1 /* ParameterCategory.ArgsList */) {
                         if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, positionParamLimitIndex === 1
                                 ? localize_1.LocMessage.argPositionalExpectedOne()
                                 : localize_1.LocMessage.argPositionalExpectedCount().format({
                                     expected: positionParamLimitIndex,
@@ -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,15 +7171,15 @@ 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
                 // parameter unless the argument is a variadic arg as well.
                 if (isParamVariadic && !isArgCompatibleWithVariadic) {
                     if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unpackedArgWithVariadicParam(), argList[argIndex].valueExpression || errorNode);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.unpackedArgWithVariadicParam(), argList[argIndex].valueExpression || errorNode);
                     }
                     reportedArgError = true;
                 }
@@ -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,
@@ -7241,7 +7237,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (remainingArgCount < remainingParamCount) {
                             if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
                                 // Have we run out of arguments and still have parameters left to fill?
-                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, remainingArgCount === 1
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, remainingArgCount === 1
                                     ? localize_1.LocMessage.argMorePositionalExpectedOne()
                                     : localize_1.LocMessage.argMorePositionalExpectedCount().format({
                                         expected: remainingArgCount,
@@ -7323,7 +7319,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             if (argsRemainingCount > 0) {
                 if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, argsRemainingCount === 1
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, argsRemainingCount === 1
                         ? localize_1.LocMessage.argMorePositionalExpectedOne()
                         : localize_1.LocMessage.argMorePositionalExpectedCount().format({
                             expected: argsRemainingCount,
@@ -7405,7 +7401,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         });
                         if (!diag.isEmpty()) {
                             if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unpackedTypedDictArgument() + diag.getString(), argList[argIndex].valueExpression || errorNode);
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.unpackedTypedDictArgument() + diag.getString(), argList[argIndex].valueExpression || errorNode);
                             }
                             reportedArgError = true;
                         }
@@ -7466,7 +7462,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             }
                             if (!isValidMappingType) {
                                 if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unpackedDictArgumentNotMapping(), argList[argIndex].valueExpression || errorNode);
+                                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.unpackedDictArgumentNotMapping(), argList[argIndex].valueExpression || errorNode);
                                 }
                                 reportedArgError = true;
                             }
@@ -7487,7 +7483,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (paramEntry && !paramEntry.isPositionalOnly) {
                             if (paramEntry.argsReceived > 0) {
                                 if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramAlreadyAssigned().format({ name: paramNameValue }), paramName);
+                                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramAlreadyAssigned().format({ name: paramNameValue }), paramName);
                                 }
                                 reportedArgError = true;
                             }
@@ -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.
@@ -7531,7 +7527,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                         else {
                             if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramNameMissing().format({ name: paramName.value }), paramName);
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramNameMissing().format({ name: paramName.value }), paramName);
                             }
                             reportedArgError = true;
                         }
@@ -7542,7 +7538,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                         else {
                             if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, positionParamLimitIndex === 1
                                     ? localize_1.LocMessage.argPositionalExpectedOne()
                                     : localize_1.LocMessage.argPositionalExpectedCount().format({
                                         expected: positionParamLimitIndex,
@@ -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,
                                 });
                             }
                         }
@@ -7619,7 +7615,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (!isDiagnosticSuppressedForNode(errorNode)) {
                         const missingParamNames = unassignedParams.map((p) => `"${p}"`).join(', ');
                         if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, unassignedParams.length === 1
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, unassignedParams.length === 1
                                 ? localize_1.LocMessage.argMissingForParam().format({ name: missingParamNames })
                                 : localize_1.LocMessage.argMissingForParams().format({ names: missingParamNames }), 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.reportGeneralTypeIssues, 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,
+                    ];
                 }
             }
         }
@@ -7867,7 +7859,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (type.boundToType && !type.boundToType.includeSubclasses && type.details.methodClass) {
             const abstractSymbolInfo = getAbstractSymbolInfo(type.details.methodClass, type.details.name);
             if (abstractSymbolInfo && !abstractSymbolInfo.hasImplementation) {
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.abstractMethodInvocation().format({
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAbstractUsage, localize_1.LocMessage.abstractMethodInvocation().format({
                     method: type.details.name,
                 }), errorNode.nodeType === 9 /* ParseNodeType.Call */ ? errorNode.leftExpression : errorNode);
             }
@@ -8021,7 +8013,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else if (type.details.paramSpec) {
             if (!sawParamSpecArgs || !sawParamSpecKwargs) {
                 if (!isTypeIncomplete) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramSpecArgsMissing().format({ type: printType(type.details.paramSpec) }), errorNode);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramSpecArgsMissing().format({ type: printType(type.details.paramSpec) }), errorNode);
                 }
                 argumentErrors = true;
                 argumentMatchScore += 1;
@@ -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,
         });
@@ -8291,7 +8282,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 argumentErrors = true;
             }
             if (argumentErrors) {
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramSpecArgsMissing().format({
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramSpecArgsMissing().format({
                     type: printType(functionType.details.paramSpec),
                 }), argErrorNode !== null && argErrorNode !== void 0 ? argErrorNode : errorNode);
             }
@@ -8356,8 +8347,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     ? 512 /* EvaluatorFlags.AllowMissingTypeArgs */ |
                         8 /* EvaluatorFlags.EvaluateStringLiteralAsType */ |
                         32 /* EvaluatorFlags.DisallowParamSpec */ |
-                        64 /* EvaluatorFlags.DisallowTypeVarTuple */
-                    : 2 /* EvaluatorFlags.DoNotSpecialize */;
+                        64 /* EvaluatorFlags.DisallowTypeVarTuple */ |
+                        16 /* EvaluatorFlags.DisallowFinal */
+                    : 2 /* EvaluatorFlags.DoNotSpecialize */ | 16 /* EvaluatorFlags.DisallowFinal */;
                 const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, !!(typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete), signatureTracker));
                 argType = exprTypeResult.type;
                 // If the type includes multiple instances of a generic function
@@ -8484,7 +8476,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Mismatching parameter types are common in untyped code; don't bother spending time
             // printing types if the diagnostic is disabled.
             const fileInfo = AnalyzerNodeInfo.getFileInfo(argParam.errorNode);
-            if (fileInfo.diagnosticRuleSet.reportGeneralTypeIssues !== 'none' &&
+            if (fileInfo.diagnosticRuleSet.reportArgumentType !== 'none' &&
                 !isDiagnosticSuppressedForNode(argParam.errorNode) &&
                 !isTypeIncomplete) {
                 const argTypeText = printType(argType);
@@ -8528,7 +8520,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (expectedTypeDiag) {
                     diag = expectedTypeDiag;
                 }
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message + diag.getString(), argParam.errorNode, (_a = diag.getEffectiveTextRange()) !== null && _a !== void 0 ? _a : argParam.errorNode);
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportArgumentType, message + diag.getString(), argParam.errorNode, (_a = diag.getEffectiveTextRange()) !== null && _a !== void 0 ? _a : argParam.errorNode);
             }
             return { isCompatible: false, argType, isTypeIncomplete, skippedBareTypeVarExpectedType, condition };
         }
@@ -8912,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 {
@@ -8966,7 +8958,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
         let className = '';
         if (argList.length !== 2) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.newTypeParamCount(), errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.newTypeParamCount(), errorNode);
             return undefined;
         }
         const nameArg = argList[0];
@@ -8976,7 +8968,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             className = nameArg.valueExpression.strings.map((s) => s.value).join('');
         }
         if (!className) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.newTypeBadName(), (_a = argList[0].node) !== null && _a !== void 0 ? _a : errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportArgumentType, localize_1.LocMessage.newTypeBadName(), (_a = argList[0].node) !== null && _a !== void 0 ? _a : errorNode);
             return undefined;
         }
         if (((_b = errorNode.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 3 /* ParseNodeType.Assignment */ &&
@@ -9166,7 +9158,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 1 /* ParseNodeType.Argument */) {
             const diag = new diagnostic_1.DiagnosticAddendum();
             diag.addMessage(localize_1.LocAddendum.useDictInstead());
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dictInAnnotation() + diag.getString(), node);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.dictInAnnotation() + diag.getString(), node);
         }
         // If the expected type is a union, analyze for each of the subtypes
         // to find one that matches.
@@ -9489,7 +9481,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 1 /* ParseNodeType.Argument */) {
             const diag = new diagnostic_1.DiagnosticAddendum();
             diag.addMessage(localize_1.LocAddendum.useListInstead());
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.listInAnnotation() + diag.getString(), node);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.listInAnnotation() + diag.getString(), node);
         }
         // If the expected type is a union, recursively call for each of the subtypes
         // to find one that matches.
@@ -10047,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.
@@ -10159,6 +10154,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     sawUnpacked = true;
                 };
                 typeList.forEach((entry, index) => {
+                    var _a;
                     let entryType = entry.type;
                     let paramCategory = 0 /* ParameterCategory.Simple */;
                     const paramName = `__p${index.toString()}`;
@@ -10170,7 +10166,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     else if (validateTypeArg(entry, { allowUnpackedTuples: true })) {
                         if ((0, types_1.isUnpackedClass)(entryType)) {
                             paramCategory = 1 /* ParameterCategory.ArgsList */;
-                            noteSawUnpacked(entry);
+                            if ((_a = entryType.tupleTypeArguments) === null || _a === void 0 ? void 0 : _a.some((typeArg) => (0, types_1.isVariadicTypeVar)(typeArg.type) || typeArg.isUnbounded)) {
+                                noteSawUnpacked(entry);
+                            }
                         }
                     }
                     else {
@@ -10273,7 +10271,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         let optionalType = (0, types_1.combineTypes)([typeArg0Type, noneClassType !== null && noneClassType !== void 0 ? noneClassType : types_1.UnknownType.create()]);
         if (unionClassType && (0, types_1.isInstantiableClass)(unionClassType)) {
-            optionalType = types_1.TypeBase.cloneAsSpecialForm(optionalType, unionClassType);
+            optionalType = types_1.TypeBase.cloneAsSpecialForm(optionalType, types_1.ClassType.cloneAsInstance(unionClassType));
         }
         return optionalType;
     }
@@ -10434,7 +10432,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         var _a;
         // Self doesn't support any type arguments.
         if (typeArgs) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeArgsExpectingNone().format({
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsExpectingNone().format({
                 name: classType.details.name,
             }), (_a = typeArgs[0].node) !== null && _a !== void 0 ? _a : errorNode);
         }
@@ -10582,7 +10580,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function createFinalType(classType, errorNode, typeArgs, flags) {
         if (flags & 16 /* EvaluatorFlags.DisallowFinal */) {
             addError(localize_1.LocMessage.finalContext(), errorNode);
-            return types_1.AnyType.create();
+            return classType;
         }
         if (!typeArgs || typeArgs.length === 0) {
             return classType;
@@ -10590,7 +10588,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (typeArgs.length > 1) {
             addError(localize_1.LocMessage.finalTooManyArgs(), errorNode);
         }
-        return typeArgs[0].type;
+        return types_1.TypeBase.cloneAsSpecialForm(typeArgs[0].type, classType);
     }
     function createConcatenateType(classType, errorNode, typeArgs, flags) {
         if ((flags & 134217728 /* EvaluatorFlags.AllowConcatenate */) === 0) {
@@ -10662,6 +10660,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 let reportedUnpackedError = false;
                 // Verify that we didn't receive any inappropriate types.
                 typeArgs.forEach((typeArg, index) => {
+                    var _a;
                     (0, debug_1.assert)(typeArgs !== undefined);
                     if ((0, typeUtils_1.isEllipsisType)(typeArg.type)) {
                         if (!isTupleTypeParam) {
@@ -10673,12 +10672,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             addError(localize_1.LocMessage.ellipsisSecondArg(), typeArg.node);
                         }
                         else {
-                            if ((0, types_1.isTypeVar)(typeArgs[0].type) &&
-                                (0, types_1.isVariadicTypeVar)(typeArgs[0].type) &&
-                                !typeArgs[0].type.isVariadicInUnion) {
+                            if ((0, types_1.isVariadicTypeVar)(typeArgs[0].type) && !typeArgs[0].type.isVariadicInUnion) {
                                 addError(localize_1.LocMessage.typeVarTupleContext(), typeArgs[0].node);
                             }
-                            else if (sawUnpacked) {
+                            else if ((0, types_1.isUnpackedClass)(typeArgs[0].type)) {
                                 addError(localize_1.LocMessage.ellipsisAfterUnpacked(), typeArg.node);
                             }
                         }
@@ -10686,14 +10683,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     else if ((0, types_1.isParamSpec)(typeArg.type) && allowParamSpec) {
                         // Nothing to do - this is allowed.
                     }
-                    else if ((0, types_1.isVariadicTypeVar)(typeArg.type) && paramLimit === undefined) {
+                    else if (paramLimit === undefined && (0, types_1.isVariadicTypeVar)(typeArg.type)) {
                         if (!typeArg.type.isVariadicInUnion) {
                             noteSawUnpacked(typeArg);
                         }
                         validateVariadicTypeVarIsUnpacked(typeArg.type, typeArg.node);
                     }
-                    else if (paramLimit === undefined && (0, types_1.isUnpacked)(typeArg.type)) {
-                        noteSawUnpacked(typeArg);
+                    else if (paramLimit === undefined && (0, types_1.isUnpackedClass)(typeArg.type)) {
+                        if ((_a = typeArg.type.tupleTypeArguments) === null || _a === void 0 ? void 0 : _a.some((typeArg) => (0, types_1.isVariadicTypeVar)(typeArg.type) || typeArg.isUnbounded)) {
+                            noteSawUnpacked(typeArg);
+                        }
                         validateTypeArg(typeArg, { allowUnpackedTuples: true });
                     }
                     else {
@@ -10810,11 +10809,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // is allowed if it's an unpacked variadic type var or tuple. None is also allowed
         // since it is used to define NoReturn in typeshed stubs).
         if (types.length === 1 && !allowSingleTypeArg && !(0, typeUtils_1.isNoneInstance)(types[0])) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unionTypeArgCount(), errorNode);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.unionTypeArgCount(), errorNode);
         }
         let unionType = (0, types_1.combineTypes)(types);
         if (unionClassType && (0, types_1.isInstantiableClass)(unionClassType)) {
-            unionType = types_1.TypeBase.cloneAsSpecialForm(unionType, unionClassType);
+            unionType = types_1.TypeBase.cloneAsSpecialForm(unionType, types_1.ClassType.cloneAsInstance(unionClassType));
         }
         return unionType;
     }
@@ -10911,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;
@@ -11114,7 +11113,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (isDeclaredTypeAlias(node.leftExpression)) {
                     typeAliasNameNode = node.leftExpression.valueExpression;
                     if (!isLegalTypeAliasExpressionForm(node.rightExpression)) {
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasIllegalExpressionForm(), node.rightExpression);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAliasIllegalExpressionForm(), node.rightExpression);
                     }
                 }
                 else if (node.leftExpression.nodeType === 38 /* ParseNodeType.Name */) {
@@ -11163,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
@@ -12234,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;
@@ -12435,7 +12446,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                     if (!assignType(annotatedType, defaultValueType, diagAddendum, typeVarContext)) {
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramAssignmentMismatch().format({
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportArgumentType, localize_1.LocMessage.paramAssignmentMismatch().format({
                             sourceType: printType(defaultValueType),
                             paramType: printType(annotatedType),
                         }) + diagAddendum.getString(), param.defaultValue);
@@ -12745,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.
@@ -13225,7 +13232,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     reportError = true;
                 }
                 if (reportError) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.importSymbolUnknown().format({ name: node.name.value }), node.name);
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAttributeAccessIssue, localize_1.LocMessage.importSymbolUnknown().format({ name: node.name.value }), node.name);
                 }
             }
             if (!symbolType) {
@@ -13306,7 +13313,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     const diagAddendum = new diagnostic_1.DiagnosticAddendum();
                     if (!assignType(declaredType, importedSymbolType, diagAddendum)) {
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAssignmentMismatchWildcard().format({
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAssignmentType, localize_1.LocMessage.typeAssignmentMismatchWildcard().format({
                             ...printSrcDestTypes(importedSymbolType, declaredType),
                             name,
                         }) + diagAddendum.getString(), node, (_b = node.wildcardToken) !== null && _b !== void 0 ? _b : node);
@@ -14008,7 +14015,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (typeArgs.length >= 1) {
                     // Treat type[function] as illegal.
                     if ((0, types_1.isFunction)(typeArgs[0].type) || (0, types_1.isOverloadedFunction)(typeArgs[0].type)) {
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAnnotationWithCallable(), typeArgs[0].node);
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAnnotationWithCallable(), typeArgs[0].node);
                         return { type: types_1.UnknownType.create() };
                     }
                 }
@@ -14051,7 +14058,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Classes that accept inlined type dict type args allow only one.
             if (typeArgs[0].inlinedTypeDict) {
                 if (typeArgs.length > 1) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeArgsTooMany().format({
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsTooMany().format({
                         name: classType.aliasName || classType.details.name,
                         expected: 1,
                         received: typeArgCount,
@@ -14062,12 +14069,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             else if (typeArgCount > typeParameters.length) {
                 if (!types_1.ClassType.isPartiallyEvaluated(classType) && !types_1.ClassType.isTupleClass(classType)) {
                     if (typeParameters.length === 0) {
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeArgsExpectingNone().format({
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsExpectingNone().format({
                             name: classType.aliasName || classType.details.name,
                         }), typeArgs[typeParameters.length].node);
                     }
                     else if (typeParameters.length !== 1 || !(0, types_1.isParamSpec)(typeParameters[0])) {
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeArgsTooMany().format({
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsTooMany().format({
                             name: classType.aliasName || classType.details.name,
                             expected: typeParameters.length,
                             received: typeArgCount,
@@ -14077,7 +14084,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             else if (typeArgCount < minTypeArgCount) {
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeArgsTooFew().format({
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsTooFew().format({
                     name: classType.aliasName || classType.details.name,
                     expected: minTypeArgCount,
                     received: typeArgCount,
@@ -14232,7 +14239,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // Avoid emitting this error for a partially-constructed class.
                     if (!(0, types_1.isClassInstance)(typeArgType) || !types_1.ClassType.isPartiallyEvaluated(typeArgType)) {
                         (0, debug_1.assert)(typeArgs !== undefined);
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarAssignmentMismatch().format({
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeVarAssignmentMismatch().format({
                             type: printType(typeArgType),
                             name: types_1.TypeVarType.getReadableName(typeParameters[index]),
                         }) + diag.getString(), typeArgs[index].node);
@@ -14821,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')) {
@@ -15076,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;
@@ -16034,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.
@@ -16063,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,
@@ -16096,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,
@@ -16108,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,
+                        });
+                    }
                 }
             }
         }
@@ -16143,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;
         }
@@ -16243,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);
             }
         }
@@ -17005,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;
@@ -17454,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.
@@ -17670,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;
@@ -18007,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)) {