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

package/dist/analyzer/typeEvaluator.js

@@ -198,6 +198,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     let dictClassType;
     let typedDictClassType;
     let typedDictPrivateClassType;
+    let supportsKeysAndGetItemProtocolType;
     let mappingType;
     let printExpressionSpaceCount = 0;
     let incompleteGenerationCount = 0;
@@ -466,7 +467,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             functionObj = getBuiltInObject(node, 'function');
             unionClassType = getTypesType(node, 'UnionType');
             if (unionClassType && (0, types_1.isClass)(unionClassType)) {
-                unionClassType.details.flags |= 1073741824 /* ClassTypeFlags.SpecialFormClass */;
+                unionClassType.details.flags |= -2147483648 /* ClassTypeFlags.SpecialFormClass */;
             }
             // Initialize and cache "Collection" to break a cyclical dependency
             // that occurs when resolving tuple below.
@@ -483,10 +484,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             typedDictClassType = getTypingType(node, 'TypedDict');
             typedDictPrivateClassType = getTypingType(node, '_TypedDict');
             awaitableProtocolType = getTypingType(node, 'Awaitable');
-            mappingType = getTypeshedType(node, 'SupportsKeysAndGetItem');
-            if (!mappingType) {
+            mappingType = getTypingType(node, 'Mapping');
+            supportsKeysAndGetItemProtocolType = getTypeshedType(node, 'SupportsKeysAndGetItem');
+            if (!supportsKeysAndGetItemProtocolType) {
                 // Fall back on 'Mapping' if 'SupportsKeysAndGetItem' is not available.
-                mappingType = getTypingType(node, 'Mapping');
+                supportsKeysAndGetItemProtocolType = mappingType;
             }
             // Wire up the `Any` class to the special-form version of our internal AnyType.
             const objectClass = getBuiltInType(node, 'object');
@@ -494,7 +496,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 */ | -2147483648 /* ClassTypeFlags.SpecialFormClass */, 
                 /* typeSourceId */ -1, 
                 /* declaredMetaclass */ undefined, 
                 /* effectiveMetaclass */ typeClassType);
@@ -1002,11 +1004,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 +1394,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;
@@ -1579,7 +1584,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // If the function includes a `**kwargs: Unpack[TypedDict]` parameter, the
     // parameter is expanded to include individual keyword args.
     function expandTypedKwargs(functionType) {
-        var _a;
+        var _a, _b;
         const kwargsIndex = functionType.details.parameters.findIndex((param) => param.category === 2 /* ParameterCategory.KwargsDict */);
         if (kwargsIndex < 0) {
             return functionType;
@@ -1589,7 +1594,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!(0, types_1.isClassInstance)(kwargsType) || !types_1.ClassType.isTypedDictClass(kwargsType) || !kwargsType.isUnpacked) {
             return functionType;
         }
-        const tdEntries = (_a = kwargsType.typedDictNarrowedEntries) !== null && _a !== void 0 ? _a : kwargsType.details.typedDictEntries;
+        const tdEntries = (_a = kwargsType.typedDictNarrowedEntries) !== null && _a !== void 0 ? _a : (_b = kwargsType.details.typedDictEntries) === null || _b === void 0 ? void 0 : _b.knownItems;
         if (!tdEntries) {
             return functionType;
         }
@@ -1779,8 +1784,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let isValidIterator = true;
         let type = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(typeResult.type);
         type = makeTopLevelTypeVarsConcrete(type);
-        if ((0, typeUtils_1.isOptionalType)(type)) {
-            if (!typeResult.isIncomplete && emitNotIterableError) {
+        type = (0, types_1.removeUnbound)(type);
+        if ((0, typeUtils_1.isOptionalType)(type) && emitNotIterableError) {
+            if (!typeResult.isIncomplete) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOptionalIterable, localize_1.LocMessage.noneNotIterable(), errorNode);
             }
             type = (0, typeUtils_1.removeNoneFromUnion)(type);
@@ -2418,15 +2424,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 });
                 // Have we accounted for all of the targets and sources? If not, we have a size mismatch.
                 if (sourceEntryTypes.length !== targetExpressions.length) {
-                    const expectedEntryCount = unpackIndex >= 0 ? targetExpressions.length - 1 : targetExpressions.length;
                     const subDiag = diagAddendum.createAddendum();
                     subDiag.addMessage((target.nodeType === 31 /* ParseNodeType.List */
                         ? localize_1.LocAddendum.listAssignmentMismatch()
                         : localize_1.LocAddendum.tupleAssignmentMismatch()).format({
                         type: printType(subtype),
                     }));
-                    subDiag.createAddendum().addMessage(localize_1.LocAddendum.tupleSizeMismatch().format({
-                        expected: expectedEntryCount,
+                    subDiag.createAddendum().addMessage((unpackIndex >= 0
+                        ? localize_1.LocAddendum.tupleSizeMismatchIndeterminateDest()
+                        : localize_1.LocAddendum.tupleSizeMismatch()).format({
+                        expected: unpackIndex >= 0 ? targetExpressions.length - 1 : targetExpressions.length,
                         received: sourceEntryTypes.length,
                     }));
                 }
@@ -2493,11 +2500,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             var _a, _b;
             if ((0, types_1.isParamSpec)(subtype)) {
                 if (subtype.paramSpecAccess === 'args') {
-                    if (tupleClassType &&
-                        (0, types_1.isInstantiableClass)(tupleClassType) &&
-                        objectType &&
-                        (0, types_1.isClassInstance)(objectType)) {
-                        return types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, [{ type: objectType, isUnbounded: true }]));
+                    if (objectType && (0, types_1.isClassInstance)(objectType)) {
+                        return makeTupleObject([{ type: objectType, isUnbounded: true }]);
                     }
                     return types_1.UnknownType.create();
                 }
@@ -3282,9 +3286,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     defaultType = (0, typeUtils_1.applySolvedTypeVars)(param, typeVarContext, { unknownIfNotFound: true });
                 }
                 else if (param.details.isVariadic && tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
-                    defaultType = types_1.ClassType.cloneForUnpacked((0, typeUtils_1.specializeTupleClass)(types_1.ClassType.cloneAsInstance(tupleClassType), [
-                        { type: types_1.UnknownType.create(), isUnbounded: true },
-                    ]));
+                    defaultType = makeTupleObject([{ type: types_1.UnknownType.create(), isUnbounded: true }], 
+                    /* isUnpackedTuple */ true);
                 }
                 else {
                     defaultType = types_1.UnknownType.create();
@@ -3904,18 +3907,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 +3931,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 +4447,49 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // param somewhere in the list?
         if (variadicIndex >= 0) {
             const variadicTypeVar = typeParameters[variadicIndex];
-            if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
-                if (variadicIndex < typeArgs.length) {
-                    const variadicTypeResults = typeArgs.slice(variadicIndex, variadicIndex + 1 + typeArgs.length - typeParameters.length);
-                    // If the type args consist of a lone variadic type variable, don't wrap it in a tuple.
-                    if (variadicTypeResults.length === 1 && (0, types_1.isVariadicTypeVar)(variadicTypeResults[0].type)) {
-                        validateVariadicTypeVarIsUnpacked(variadicTypeResults[0].type, variadicTypeResults[0].node);
-                    }
-                    else {
-                        variadicTypeResults.forEach((arg, index) => {
-                            validateTypeArg(arg, {
-                                allowEmptyTuple: index === 0,
-                                allowVariadicTypeVar: true,
-                                allowUnpackedTuples: true,
-                            });
+            if (variadicIndex < typeArgs.length) {
+                const variadicTypeResults = typeArgs.slice(variadicIndex, variadicIndex + 1 + typeArgs.length - typeParameters.length);
+                // If the type args consist of a lone variadic type variable, don't wrap it in a tuple.
+                if (variadicTypeResults.length === 1 && (0, types_1.isVariadicTypeVar)(variadicTypeResults[0].type)) {
+                    validateVariadicTypeVarIsUnpacked(variadicTypeResults[0].type, variadicTypeResults[0].node);
+                }
+                else {
+                    variadicTypeResults.forEach((arg, index) => {
+                        validateTypeArg(arg, {
+                            allowEmptyTuple: index === 0,
+                            allowVariadicTypeVar: true,
+                            allowUnpackedTuples: true,
                         });
-                        const variadicTypes = [];
-                        if (variadicTypeResults.length !== 1 || !variadicTypeResults[0].isEmptyTupleShorthand) {
-                            variadicTypeResults.forEach((typeResult) => {
-                                if ((0, types_1.isUnpackedClass)(typeResult.type) && typeResult.type.tupleTypeArguments) {
-                                    (0, collectionUtils_1.appendArray)(variadicTypes, typeResult.type.tupleTypeArguments);
-                                }
-                                else {
-                                    variadicTypes.push({
-                                        type: (0, typeUtils_1.convertToInstance)(typeResult.type),
-                                        isUnbounded: false,
-                                    });
-                                }
-                            });
-                        }
-                        const tupleObject = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, variadicTypes, 
-                        /* isTypeArgumentExplicit */ true, 
-                        /* isUnpackedTuple */ true));
-                        typeArgs = [
-                            ...typeArgs.slice(0, variadicIndex),
-                            { node: typeArgs[variadicIndex].node, type: tupleObject },
-                            ...typeArgs.slice(variadicIndex + 1 + typeArgs.length - typeParameters.length, typeArgs.length),
-                        ];
-                    }
-                }
-                else if (!variadicTypeVar.details.defaultType) {
-                    // Add an empty tuple that maps to the TypeVarTuple type parameter.
-                    typeArgs.push({
-                        node: errorNode,
-                        type: (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, [], 
-                        /* isTypeArgumentExplicit */ true, 
-                        /* isUnpackedTuple */ true)),
                     });
+                    const variadicTypes = [];
+                    if (variadicTypeResults.length !== 1 || !variadicTypeResults[0].isEmptyTupleShorthand) {
+                        variadicTypeResults.forEach((typeResult) => {
+                            if ((0, types_1.isUnpackedClass)(typeResult.type) && typeResult.type.tupleTypeArguments) {
+                                (0, collectionUtils_1.appendArray)(variadicTypes, typeResult.type.tupleTypeArguments);
+                            }
+                            else {
+                                variadicTypes.push({
+                                    type: (0, typeUtils_1.convertToInstance)(typeResult.type),
+                                    isUnbounded: false,
+                                });
+                            }
+                        });
+                    }
+                    const tupleObject = makeTupleObject(variadicTypes, /* isUnpackedTuple */ true);
+                    typeArgs = [
+                        ...typeArgs.slice(0, variadicIndex),
+                        { node: typeArgs[variadicIndex].node, type: tupleObject },
+                        ...typeArgs.slice(variadicIndex + 1 + typeArgs.length - typeParameters.length, typeArgs.length),
+                    ];
                 }
             }
+            else if (!variadicTypeVar.details.defaultType) {
+                // Add an empty tuple that maps to the TypeVarTuple type parameter.
+                typeArgs.push({
+                    node: errorNode,
+                    type: makeTupleObject([], /* isUnpackedTuple */ true),
+                });
+            }
         }
         return typeArgs;
     }
@@ -4936,11 +4933,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         });
     }
-    function makeTupleObject(entryTypes, isUnspecifiedLength = false) {
+    function makeTupleObject(typeArgs, isUnpackedTuple = false) {
         if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
-            return (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, entryTypes.map((t) => {
-                return { type: t, isUnbounded: isUnspecifiedLength };
-            })));
+            return (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, typeArgs, /* isTypeArgumentExplicit */ true, isUnpackedTuple));
         }
         return types_1.UnknownType.create();
     }
@@ -5032,17 +5027,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 +5046,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 +5093,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 +5118,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 +5140,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return undefined;
         }
         const slicedTypeArgs = tupleTypeArgs.slice(startValue, endValue);
-        return types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleType, slicedTypeArgs));
+        return makeTupleObject(slicedTypeArgs);
     }
     function getTupleSliceParameter(expression, defaultValue, tupleTypeArgs) {
         let value = defaultValue;
@@ -5412,8 +5408,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 +5424,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getTypeOfTupleInferred(node) {
         const entryTypeResults = node.expressions.map((expr) => getTypeOfExpression(expr));
         const isIncomplete = entryTypeResults.some((result) => result.isIncomplete);
-        if (!tupleClassType || !(0, types_1.isInstantiableClass)(tupleClassType)) {
-            return { type: types_1.UnknownType.create() };
-        }
-        const type = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, buildTupleTypesList(entryTypeResults)));
+        const type = makeTupleObject(buildTupleTypesList(entryTypeResults));
         if (isIncomplete) {
             if ((0, typeUtils_1.getContainerDepth)(type) > maxInferredContainerDepth) {
                 return { type: types_1.UnknownType.create() };
@@ -5889,10 +5881,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 +5895,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             let resultType;
             if (lookupResults && (0, types_1.isInstantiableClass)(lookupResults.classType)) {
                 resultType = lookupResults.classType;
+                if (isProtocolClass) {
+                    // If the bindToType is a protocol class, set the "include subclasses" flag
+                    // so we don't enforce that called methods are implemented within the protocol.
+                    resultType = types_1.ClassType.cloneIncludeSubclasses(resultType);
+                }
             }
             else if (effectiveTargetClass &&
                 !(0, types_1.isAnyOrUnknown)(effectiveTargetClass) &&
@@ -6416,7 +6415,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (callTypeResult.type.specialForm) {
             const exprNode = errorNode.nodeType === 9 /* ParseNodeType.Call */ ? errorNode.leftExpression : errorNode;
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.objectNotCallable().format({
-                type: printType(callTypeResult.type, { expandTypeAlias: true }),
+                type: printType(callTypeResult.type.specialForm, { expandTypeAlias: true }),
             }), exprNode);
             return { returnType: types_1.UnknownType.create(), argumentErrors: true, overloadsUsedForCall };
         }
@@ -6873,7 +6872,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function evaluateCastCall(argList, errorNode) {
         // Verify that the cast is necessary.
         const castToType = getTypeOfArgumentExpectingType(argList[0], { enforceTypeAnnotationRules: true }).type;
-        const castFromType = getTypeOfArgument(argList[1]).type;
+        let castFromType = getTypeOfArgument(argList[1]).type;
+        if (castFromType.specialForm) {
+            castFromType = castFromType.specialForm;
+        }
         if (types_1.TypeBase.isInstantiable(castToType) && !(0, types_1.isUnknown)(castToType)) {
             if ((0, types_1.isTypeSame)((0, typeUtils_1.convertToInstance)(castToType), castFromType, {
                 ignorePseudoGeneric: true,
@@ -6906,7 +6908,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     argumentCategory: 1 /* ArgumentCategory.UnpackedList */,
                                     valueExpression: undefined,
                                     typeResult: {
-                                        type: (0, typeUtils_1.specializeTupleClass)(combinedArgType, [tupleTypeArg]),
+                                        type: makeTupleObject([tupleTypeArg]),
                                     },
                                 });
                             }
@@ -6934,7 +6936,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // validation is left to the caller.
     // This logic is based on PEP 3102: https://www.python.org/dev/peps/pep-3102/
     function matchFunctionArgumentsToParameters(errorNode, argList, typeResult, overloadIndex) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         const paramDetails = (0, parameterUtils_1.getParameterListDetails)(typeResult.type);
         let argIndex = 0;
         let matchedUnpackedListOfUnknownLength = false;
@@ -7162,10 +7164,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     listElementType = undefined;
                 }
                 else {
-                    listElementType =
-                        (_e = (_d = getTypeOfIterator({ type: argType, isIncomplete: argTypeResult.isIncomplete }, 
-                        /* isAsync */ false, errorNode, 
-                        /* emitNotIterableError */ false)) === null || _d === void 0 ? void 0 : _d.type) !== null && _e !== void 0 ? _e : types_1.UnknownType.create();
+                    listElementType = (_d = getTypeOfIterator({ type: argType, isIncomplete: argTypeResult.isIncomplete }, 
+                    /* isAsync */ false, errorNode, 
+                    /* emitNotIterableError */ false)) === null || _d === void 0 ? void 0 : _d.type;
                     if (paramDetails.params[paramIndex].param.category !== 1 /* ParameterCategory.ArgsList */) {
                         matchedUnpackedListOfUnknownLength = true;
                     }
@@ -7175,8 +7176,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         argumentCategory: 0 /* ArgumentCategory.Simple */,
                         typeResult: { type: listElementType, isIncomplete: argTypeResult.isIncomplete },
                     }
-                    : undefined;
-                if (funcArg && argTypeResult.isIncomplete) {
+                    : { ...argList[argIndex] };
+                if (argTypeResult.isIncomplete) {
                     isTypeIncomplete = true;
                 }
                 // It's not allowed to use unpacked arguments with a variadic *args
@@ -7197,7 +7198,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,
@@ -7349,7 +7350,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // keys are present.
                         const typedDictEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluatorInterface, argType);
                         const diag = new diagnostic_1.DiagnosticAddendum();
-                        typedDictEntries.forEach((entry, name) => {
+                        typedDictEntries.knownItems.forEach((entry, name) => {
                             const paramEntry = paramMap.get(name);
                             if (paramEntry && !paramEntry.isPositionalOnly) {
                                 if (paramEntry.argsReceived > 0) {
@@ -7426,20 +7427,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     else {
                         const strObjType = getBuiltInObject(errorNode, 'str');
-                        if (mappingType &&
-                            (0, types_1.isInstantiableClass)(mappingType) &&
+                        if (supportsKeysAndGetItemProtocolType &&
+                            (0, types_1.isInstantiableClass)(supportsKeysAndGetItemProtocolType) &&
                             strObjType &&
                             (0, types_1.isClassInstance)(strObjType)) {
-                            const mappingTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(mappingType));
+                            const mappingTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(supportsKeysAndGetItemProtocolType));
                             let isValidMappingType = false;
                             // If this was a TypeVar (e.g. for pseudo-generic classes),
                             // don't emit this error.
                             if ((0, types_1.isTypeVar)(argType)) {
                                 isValidMappingType = true;
                             }
-                            else if (assignType(types_1.ClassType.cloneAsInstance(mappingType), argType, 
+                            else if (assignType(types_1.ClassType.cloneAsInstance(supportsKeysAndGetItemProtocolType), argType, 
                             /* diag */ undefined, mappingTypeVarContext)) {
-                                const specializedMapping = (0, typeUtils_1.applySolvedTypeVars)(mappingType, mappingTypeVarContext);
+                                const specializedMapping = (0, typeUtils_1.applySolvedTypeVars)(supportsKeysAndGetItemProtocolType, mappingTypeVarContext);
                                 const typeArgs = specializedMapping.typeArguments;
                                 if (typeArgs && typeArgs.length >= 2) {
                                     if (assignType(strObjType, typeArgs[0])) {
@@ -7501,7 +7502,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 +7518,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 paramType,
                                 requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                                 argument: argList[argIndex],
-                                errorNode: (_h = argList[argIndex].valueExpression) !== null && _h !== void 0 ? _h : errorNode,
+                                errorNode: (_g = argList[argIndex].valueExpression) !== null && _g !== void 0 ? _g : errorNode,
                                 paramName: paramNameValue,
                             });
                             // Remember that this parameter has already received a value.
@@ -7567,7 +7568,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,
                                 });
                             }
                         }
@@ -7649,6 +7650,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                         argumentCategory: 0 /* ArgumentCategory.Simple */,
                                         typeResult: { type: defaultArgType },
                                     },
+                                    isDefaultArg: true,
                                     errorNode,
                                     paramName: param.name,
                                     isParamNameSynthesized: param.isNameSynthesized,
@@ -7675,61 +7677,57 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const paramType = paramDetails.params[paramDetails.argsIndex].type;
                 const variadicArgs = validateArgTypeParams.filter((argParam) => argParam.mapsToVarArgList);
                 if ((0, types_1.isVariadicTypeVar)(paramType) && !paramType.isVariadicInUnion) {
-                    if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
-                        const tupleTypeArgs = variadicArgs.map((argParam) => {
-                            var _a;
-                            const argType = getTypeOfArgument(argParam.argument).type;
-                            const containsVariadicTypeVar = (0, types_1.isUnpackedVariadicTypeVar)(argType) ||
-                                ((0, types_1.isClassInstance)(argType) &&
-                                    (0, typeUtils_1.isTupleClass)(argType) &&
-                                    argType.tupleTypeArguments &&
-                                    argType.tupleTypeArguments.length === 1 &&
-                                    (0, types_1.isUnpackedVariadicTypeVar)(argType.tupleTypeArguments[0].type));
-                            if (containsVariadicTypeVar &&
-                                argParam.argument.argumentCategory !== 1 /* ArgumentCategory.UnpackedList */ &&
-                                !argParam.mapsToVarArgList) {
-                                if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-                                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.typeVarTupleMustBeUnpacked(), (_a = argParam.argument.valueExpression) !== null && _a !== void 0 ? _a : errorNode);
-                                }
-                                reportedArgError = true;
+                    const tupleTypeArgs = variadicArgs.map((argParam) => {
+                        var _a;
+                        const argType = getTypeOfArgument(argParam.argument).type;
+                        const containsVariadicTypeVar = (0, types_1.isUnpackedVariadicTypeVar)(argType) ||
+                            ((0, types_1.isClassInstance)(argType) &&
+                                (0, typeUtils_1.isTupleClass)(argType) &&
+                                argType.tupleTypeArguments &&
+                                argType.tupleTypeArguments.length === 1 &&
+                                (0, types_1.isUnpackedVariadicTypeVar)(argType.tupleTypeArguments[0].type));
+                        if (containsVariadicTypeVar &&
+                            argParam.argument.argumentCategory !== 1 /* ArgumentCategory.UnpackedList */ &&
+                            !argParam.mapsToVarArgList) {
+                            if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.typeVarTupleMustBeUnpacked(), (_a = argParam.argument.valueExpression) !== null && _a !== void 0 ? _a : errorNode);
                             }
-                            return {
-                                type: argType,
-                                isUnbounded: argParam.argument.argumentCategory === 1 /* ArgumentCategory.UnpackedList */,
-                            };
-                        });
-                        let specializedTuple;
-                        if (tupleTypeArgs.length === 1 &&
-                            !tupleTypeArgs[0].isUnbounded &&
-                            ((0, types_1.isUnpackedClass)(tupleTypeArgs[0].type) || (0, types_1.isVariadicTypeVar)(tupleTypeArgs[0].type))) {
-                            // If there is a single unpacked tuple or unpacked variadic type variable
-                            // (including an unpacked TypeVarTuple union) within this tuple,
-                            // simplify the type.
-                            specializedTuple = tupleTypeArgs[0].type;
-                        }
-                        else {
-                            specializedTuple = types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, tupleTypeArgs, 
-                            /* isTypeArgumentExplicit */ true, 
-                            /* isUnpackedTuple */ true));
+                            reportedArgError = true;
                         }
-                        const combinedArg = {
-                            paramCategory: 1 /* ParameterCategory.ArgsList */,
-                            paramType,
-                            requiresTypeVarMatching: true,
-                            argument: {
-                                argumentCategory: 0 /* ArgumentCategory.Simple */,
-                                typeResult: { type: specializedTuple },
-                            },
-                            errorNode,
-                            paramName: paramDetails.params[paramDetails.argsIndex].param.name,
-                            isParamNameSynthesized: paramDetails.params[paramDetails.argsIndex].param.isNameSynthesized,
-                            mapsToVarArgList: true,
+                        return {
+                            type: argType,
+                            isUnbounded: argParam.argument.argumentCategory === 1 /* ArgumentCategory.UnpackedList */,
                         };
-                        validateArgTypeParams = [
-                            ...validateArgTypeParams.filter((argParam) => !argParam.mapsToVarArgList),
-                            combinedArg,
-                        ];
+                    });
+                    let specializedTuple;
+                    if (tupleTypeArgs.length === 1 &&
+                        !tupleTypeArgs[0].isUnbounded &&
+                        ((0, types_1.isUnpackedClass)(tupleTypeArgs[0].type) || (0, types_1.isVariadicTypeVar)(tupleTypeArgs[0].type))) {
+                        // If there is a single unpacked tuple or unpacked variadic type variable
+                        // (including an unpacked TypeVarTuple union) within this tuple,
+                        // simplify the type.
+                        specializedTuple = tupleTypeArgs[0].type;
                     }
+                    else {
+                        specializedTuple = makeTupleObject(tupleTypeArgs, /* isUnpackedTuple */ true);
+                    }
+                    const combinedArg = {
+                        paramCategory: 1 /* ParameterCategory.ArgsList */,
+                        paramType,
+                        requiresTypeVarMatching: true,
+                        argument: {
+                            argumentCategory: 0 /* ArgumentCategory.Simple */,
+                            typeResult: { type: specializedTuple },
+                        },
+                        errorNode,
+                        paramName: paramDetails.params[paramDetails.argsIndex].param.name,
+                        isParamNameSynthesized: paramDetails.params[paramDetails.argsIndex].param.isNameSynthesized,
+                        mapsToVarArgList: true,
+                    };
+                    validateArgTypeParams = [
+                        ...validateArgTypeParams.filter((argParam) => !argParam.mapsToVarArgList),
+                        combinedArg,
+                    ];
                 }
             }
         }
@@ -8067,7 +8065,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let specializedReturnType = (0, typeUtils_1.applySolvedTypeVars)(returnType, typeVarContext, {
             unknownIfNotFound,
             unknownExemptTypeVars: getUnknownExemptTypeVarsForReturnType(type, returnType),
-            useUnknownOverDefault: skipUnknownArgCheck,
             eliminateUnsolvedInUnions,
             applyInScopePlaceholders: true,
         });
@@ -8085,15 +8082,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isUnpackedClass)(specializedReturnType)) {
             specializedReturnType = types_1.ClassType.cloneForUnpacked(specializedReturnType, /* isUnpackedTuple */ false);
         }
-        // Handle 'TypeGuard' specially. We'll transform the return type into a 'bool'
-        // object with a type argument that reflects the narrowed type.
+        // Handle 'TypeGuard' and 'TypeIs' specially. We'll transform the return type
+        // into a 'bool' object with a type argument that reflects the narrowed type.
         if ((0, types_1.isClassInstance)(specializedReturnType) &&
-            types_1.ClassType.isBuiltIn(specializedReturnType, 'TypeGuard') &&
+            types_1.ClassType.isBuiltIn(specializedReturnType, ['TypeGuard', 'TypeIs']) &&
             specializedReturnType.typeArguments &&
-            specializedReturnType.typeArguments.length > 0 &&
-            (0, types_1.isClassInstance)(returnType) &&
-            returnType.typeArguments &&
-            returnType.typeArguments.length > 0) {
+            specializedReturnType.typeArguments.length > 0) {
             if (boolClassType && (0, types_1.isInstantiableClass)(boolClassType)) {
                 let typeGuardType = specializedReturnType.typeArguments[0];
                 // If the first argument is a simple (non-constrained) TypeVar,
@@ -8108,21 +8102,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         ]);
                     }
                 }
-                let useStrictTypeGuardSemantics = false;
-                if (AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.enableExperimentalFeatures) {
-                    // Determine the type of the first parameter.
-                    const paramIndex = type.boundToType ? 1 : 0;
-                    if (paramIndex < type.details.parameters.length) {
-                        const paramType = types_1.FunctionType.getEffectiveParameterType(type, paramIndex);
-                        // If the type guard meets the requirements that the first parameter
-                        // type is a proper subtype of the return type, we can use strict
-                        // type guard semantics.
-                        if (assignType(paramType, returnType.typeArguments[0])) {
-                            useStrictTypeGuardSemantics = true;
-                        }
-                    }
-                }
-                specializedReturnType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForTypeGuard(boolClassType, typeGuardType, useStrictTypeGuardSemantics));
+                const useTypeIsSemantics = types_1.ClassType.isBuiltIn(specializedReturnType, 'TypeIs');
+                specializedReturnType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForTypeGuard(boolClassType, typeGuardType, useTypeIsSemantics));
             }
         }
         specializedReturnType = adjustCallableReturnType(specializedReturnType, signatureTracker.getTrackedSignatures());
@@ -8400,6 +8381,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     isTypeIncomplete = true;
                 }
             }
+            // If the argument came from a parameter's default argument value,
+            // we may need to specialize the type.
+            if (argParam.isDefaultArg) {
+                argType = (0, typeUtils_1.applySolvedTypeVars)(argType, typeVarContext);
+            }
         }
         // If we're assigning to a var arg dictionary with a TypeVar type,
         // strip literals before performing the assignment. This is used in
@@ -8913,7 +8899,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 {
@@ -9006,7 +8992,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.newTypeLiteral(), argList[1].node || errorNode);
         }
         let classFlags = baseClass.details.flags & ~(1 /* ClassTypeFlags.BuiltInClass */ | 2 /* ClassTypeFlags.SpecialBuiltIn */);
-        classFlags |= 4096 /* ClassTypeFlags.Final */ | 268435456 /* ClassTypeFlags.NewTypeClass */ | 536870912 /* ClassTypeFlags.ValidTypeAliasClass */;
+        classFlags |= 8192 /* ClassTypeFlags.Final */ | 536870912 /* ClassTypeFlags.NewTypeClass */ | 1073741824 /* ClassTypeFlags.ValidTypeAliasClass */;
         const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, classFlags, ParseTreeUtils.getTypeSourceId(errorNode), 
         /* declaredMetaclass */ undefined, baseClass.details.effectiveMetaclass);
         classType.details.baseClasses.push(isBaseClassAny ? types_1.AnyType.create() : baseClass);
@@ -9055,7 +9041,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!(0, types_1.isClassInstance)(arg1Type) || !(0, typeUtils_1.isTupleClass)(arg1Type) || arg1Type.tupleTypeArguments === undefined) {
             return undefined;
         }
-        const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, 536870912 /* ClassTypeFlags.ValidTypeAliasClass */, ParseTreeUtils.getTypeSourceId(errorNode), 
+        const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, 1073741824 /* ClassTypeFlags.ValidTypeAliasClass */, ParseTreeUtils.getTypeSourceId(errorNode), 
         /* declaredMetaclass */ undefined, arg1Type.details.effectiveMetaclass);
         arg1Type.tupleTypeArguments.forEach((typeArg) => {
             const specializedType = makeTopLevelTypeVarsConcrete(typeArg.type);
@@ -9365,8 +9351,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     (0, types_1.isClassInstance)(keyType) &&
                     types_1.ClassType.isBuiltIn(keyType, 'str') &&
                     (0, typeUtils_1.isLiteralType)(keyType) &&
-                    expectedTypedDictEntries.has(keyType.literalValue)) {
-                    const effectiveValueType = expectedTypedDictEntries.get(keyType.literalValue).valueType;
+                    expectedTypedDictEntries.knownItems.has(keyType.literalValue)) {
+                    const effectiveValueType = expectedTypedDictEntries.knownItems.get(keyType.literalValue).valueType;
                     entryInferenceContext = (0, typeUtils_1.makeInferenceContext)(effectiveValueType);
                     valueTypeResult = getTypeOfExpression(entryNode.valueExpression, 
                     /* flags */ undefined, entryInferenceContext);
@@ -9399,8 +9385,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             else if (entryNode.nodeType === 16 /* ParseNodeType.DictionaryExpandEntry */) {
                 let expectedType;
                 if (expectedKeyType && expectedValueType) {
-                    if (mappingType && (0, types_1.isInstantiableClass)(mappingType)) {
-                        expectedType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(mappingType, [expectedKeyType, expectedValueType], 
+                    if (supportsKeysAndGetItemProtocolType && (0, types_1.isInstantiableClass)(supportsKeysAndGetItemProtocolType)) {
+                        expectedType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(supportsKeysAndGetItemProtocolType, [expectedKeyType, expectedValueType], 
                         /* isTypeArgumentExplicit */ true));
                     }
                 }
@@ -9426,7 +9412,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         const strObject = types_1.ClassType.cloneAsInstance(strClassType);
                         const tdEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluatorInterface, unexpandedType, 
                         /* allowNarrowed */ true);
-                        tdEntries.forEach((entry, name) => {
+                        tdEntries.knownItems.forEach((entry, name) => {
                             if (entry.isRequired || entry.isProvided) {
                                 keyTypes.push({ node: entryNode, type: types_1.ClassType.cloneWithLiteral(strObject, name) });
                                 valueTypes.push({ node: entryNode, type: entry.valueType });
@@ -9435,13 +9421,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         addUnknown = false;
                     }
                 }
-                else if (mappingType && (0, types_1.isInstantiableClass)(mappingType)) {
-                    const mappingTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(mappingType));
-                    mappingType = (0, typeUtils_1.selfSpecializeClass)(mappingType);
-                    if (assignType(types_1.ClassType.cloneAsInstance(mappingType), unexpandedType, 
+                else if (supportsKeysAndGetItemProtocolType &&
+                    (0, types_1.isInstantiableClass)(supportsKeysAndGetItemProtocolType)) {
+                    const mappingTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(supportsKeysAndGetItemProtocolType));
+                    supportsKeysAndGetItemProtocolType = (0, typeUtils_1.selfSpecializeClass)(supportsKeysAndGetItemProtocolType);
+                    if (assignType(types_1.ClassType.cloneAsInstance(supportsKeysAndGetItemProtocolType), unexpandedType, 
                     /* diag */ undefined, mappingTypeVarContext, 
                     /* srcTypeVarContext */ undefined, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */)) {
-                        const specializedMapping = (0, typeUtils_1.applySolvedTypeVars)(mappingType, mappingTypeVarContext);
+                        const specializedMapping = (0, typeUtils_1.applySolvedTypeVars)(supportsKeysAndGetItemProtocolType, mappingTypeVarContext);
                         const typeArgs = specializedMapping.typeArguments;
                         if (typeArgs && typeArgs.length >= 2) {
                             if (forceStrictInference || index < maxEntriesToUseForInference) {
@@ -9916,7 +9903,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }, {
-            dependentType: expectedType,
+            dependentType: inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType,
             allowDiagnostics: !forceSpeculative && !isDiagnosticSuppressedForNode(node) && !(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete),
         });
         // Mark the function type as no longer being evaluated.
@@ -10048,7 +10035,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.
@@ -10411,7 +10401,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return type;
     }
-    // Creates a "TypeGuard" type. This is an alias for 'bool', which
+    // Creates a "TypeGuard" and "TypeIs" type. This is an alias for 'bool', which
     // isn't a generic type and therefore doesn't have a typeParameter.
     // We'll abuse our internal types a bit by specializing it with
     // a type argument anyway.
@@ -10916,7 +10906,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;
@@ -10929,12 +10919,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         /* declaredMetaclass */ undefined, 
         /* effectiveMetaclass */ undefined);
         if (aliasMapEntry.isSpecialForm) {
-            specialClassType.details.flags |= 1073741824 /* ClassTypeFlags.SpecialFormClass */;
+            specialClassType.details.flags |= -2147483648 /* ClassTypeFlags.SpecialFormClass */;
         }
         const specialBuiltInClassDeclaration = ((_a = AnalyzerNodeInfo.getDeclaration(node)) !== null && _a !== void 0 ? _a : (node.parent ? AnalyzerNodeInfo.getDeclaration(node.parent) : undefined));
         specialClassType.details.declaration = specialBuiltInClassDeclaration;
         if (fileInfo.isTypingExtensionsStubFile) {
-            specialClassType.details.flags |= 65536 /* ClassTypeFlags.TypingExtensionClass */;
+            specialClassType.details.flags |= 131072 /* ClassTypeFlags.TypingExtensionClass */;
         }
         const baseClassName = aliasMapEntry.alias || 'object';
         let baseClass;
@@ -10954,7 +10944,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // cause the TypedDict to be marked as abstract.
                 if ((0, types_1.isInstantiableClass)(baseClass) && types_1.ClassType.isBuiltIn(baseClass, '_TypedDict')) {
                     baseClass = types_1.ClassType.cloneWithNewFlags(baseClass, baseClass.details.flags &
-                        ~(1024 /* ClassTypeFlags.SupportsAbstractMethods */ | 134217728 /* ClassTypeFlags.TypeCheckOnly */));
+                        ~(2048 /* ClassTypeFlags.SupportsAbstractMethods */ | 268435456 /* ClassTypeFlags.TypeCheckOnly */));
                 }
             }
         }
@@ -11010,6 +11000,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             ['Never', { alias: '', module: 'builtins', isSpecialForm: true }],
             ['LiteralString', { alias: '', module: 'builtins', isSpecialForm: true }],
             ['ReadOnly', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['TypeIs', { alias: '', module: 'builtins', isSpecialForm: true }],
         ]);
         const aliasMapEntry = specialTypes.get(assignedName);
         if (aliasMapEntry) {
@@ -11168,9 +11159,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
@@ -11328,17 +11329,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             fileInfo.isTypeshedStubFile) {
             classFlags |= 1 /* ClassTypeFlags.BuiltInClass */;
             if (fileInfo.isTypingExtensionsStubFile) {
-                classFlags |= 65536 /* ClassTypeFlags.TypingExtensionClass */;
+                classFlags |= 131072 /* ClassTypeFlags.TypingExtensionClass */;
             }
             if (node.name.value === 'property') {
-                classFlags |= 2048 /* ClassTypeFlags.PropertyClass */;
+                classFlags |= 4096 /* ClassTypeFlags.PropertyClass */;
             }
             if (node.name.value === 'tuple') {
-                classFlags |= 524288 /* ClassTypeFlags.TupleClass */;
+                classFlags |= 1048576 /* ClassTypeFlags.TupleClass */;
             }
         }
         if (fileInfo.isStubFile) {
-            classFlags |= 8388608 /* ClassTypeFlags.DefinedInStub */;
+            classFlags |= 16777216 /* ClassTypeFlags.DefinedInStub */;
         }
         const classType = types_1.ClassType.createInstantiable(node.name.value, ParseTreeUtils.getClassFullName(node, fileInfo.moduleName, node.name.value), fileInfo.moduleName, fileInfo.fileUri, classFlags, 
         /* typeSourceId */ 0, 
@@ -11361,7 +11362,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (classDecl && classSymbol) {
             setSymbolResolutionPartialType(classSymbol, classDecl, classType);
         }
-        classType.details.flags |= 131072 /* ClassTypeFlags.PartiallyEvaluated */;
+        classType.details.flags |= 262144 /* ClassTypeFlags.PartiallyEvaluated */;
         classType.details.declaration = classDecl;
         try {
             writeTypeCache(node, { type: classType }, /* flags */ undefined);
@@ -11446,10 +11447,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     fileInfo.executionEnvironment.pythonVersion < pythonVersion_1.PythonVersion.V3_7) {
                                     addError(localize_1.LocMessage.protocolIllegal(), arg.valueExpression);
                                 }
-                                classType.details.flags |= 8192 /* ClassTypeFlags.ProtocolClass */;
+                                classType.details.flags |= 16384 /* ClassTypeFlags.ProtocolClass */;
                             }
                             if (types_1.ClassType.isBuiltIn(argType, 'property')) {
-                                classType.details.flags |= 2048 /* ClassTypeFlags.PropertyClass */;
+                                classType.details.flags |= 4096 /* ClassTypeFlags.PropertyClass */;
                             }
                             // If the class directly derives from NamedTuple (in Python 3.6 or
                             // newer), it's considered a (read-only) dataclass.
@@ -11458,13 +11459,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     classType.details.flags |=
                                         4 /* ClassTypeFlags.DataClass */ |
                                             32 /* ClassTypeFlags.SkipSynthesizedDataClassEq */ |
-                                            16777216 /* ClassTypeFlags.ReadOnlyInstanceVariables */;
+                                            33554432 /* ClassTypeFlags.ReadOnlyInstanceVariables */;
                                 }
                             }
                             // If the class directly derives from TypedDict or from a class that is
                             // a TypedDict, it is considered a TypedDict.
                             if (types_1.ClassType.isBuiltIn(argType, 'TypedDict') || types_1.ClassType.isTypedDictClass(argType)) {
                                 classType.details.flags |= 128 /* ClassTypeFlags.TypedDictClass */;
+                                // Propagate the "effectively closed" flag from base classes.
+                                if (types_1.ClassType.isTypedDictEffectivelyClosed(argType)) {
+                                    classType.details.flags |= 512 /* ClassTypeFlags.TypedDictEffectivelyClosed */;
+                                }
                             }
                             // Validate that the class isn't deriving from itself, creating a
                             // circular dependency.
@@ -11494,7 +11499,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     classType.details.baseClasses.push(argType);
                     if ((0, types_1.isInstantiableClass)(argType)) {
                         if (types_1.ClassType.isEnumClass(argType)) {
-                            classType.details.flags |= 1048576 /* ClassTypeFlags.EnumClass */;
+                            classType.details.flags |= 2097152 /* ClassTypeFlags.EnumClass */;
                         }
                         // Determine if the class is abstract. Protocol classes support abstract methods
                         // because they are constructed by the _ProtocolMeta metaclass, which derives
@@ -11503,10 +11508,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // because of dependencies on some of these built-in protocol classes.
                         if (types_1.ClassType.supportsAbstractMethods(argType) ||
                             (types_1.ClassType.isProtocolClass(argType) && !types_1.ClassType.isBuiltIn(argType))) {
-                            classType.details.flags |= 1024 /* ClassTypeFlags.SupportsAbstractMethods */;
+                            classType.details.flags |= 2048 /* ClassTypeFlags.SupportsAbstractMethods */;
                         }
                         if (types_1.ClassType.isPropertyClass(argType)) {
-                            classType.details.flags |= 2048 /* ClassTypeFlags.PropertyClass */;
+                            classType.details.flags |= 4096 /* ClassTypeFlags.PropertyClass */;
                         }
                         if (types_1.ClassType.isFinal(argType)) {
                             const className = printObjectTypeForClass(argType);
@@ -11548,7 +11553,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 else if (types_1.ClassType.isTypedDictClass(classType)) {
-                    if (arg.name.value === 'total') {
+                    if (arg.name.value === 'total' || arg.name.value === 'closed') {
                         // The "total" and "readonly" parameters apply only for TypedDict classes.
                         // PEP 589 specifies that the parameter must be either True or False.
                         const constArgValue = (0, staticExpressions_1.evaluateStaticBoolExpression)(arg.valueExpression, fileInfo.executionEnvironment, fileInfo.definedConstants);
@@ -11556,7 +11561,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             addError(localize_1.LocMessage.typedDictBoolParam().format({ name: arg.name.value }), arg.valueExpression);
                         }
                         else if (arg.name.value === 'total' && !constArgValue) {
-                            classType.details.flags |= 256 /* ClassTypeFlags.CanOmitDictValues */;
+                            classType.details.flags |= 1024 /* ClassTypeFlags.CanOmitDictValues */;
+                        }
+                        else if (arg.name.value === 'closed' && constArgValue) {
+                            if (AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures) {
+                                classType.details.flags |=
+                                    256 /* ClassTypeFlags.TypedDictMarkedClosed */ | 512 /* ClassTypeFlags.TypedDictEffectivelyClosed */;
+                            }
                         }
                     }
                     else {
@@ -11677,7 +11688,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 param.category === 0 /* ParameterCategory.Simple */ &&
                                 !param.defaultValue);
                             if (genericParams.length > 0) {
-                                classType.details.flags |= 16384 /* ClassTypeFlags.PseudoGenericClass */;
+                                classType.details.flags |= 32768 /* ClassTypeFlags.PseudoGenericClass */;
                                 // Create a type parameter for each simple, named parameter
                                 // in the __init__ method.
                                 classType.details.typeParameters = genericParams.map((param) => {
@@ -11698,7 +11709,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (classType.details.typeParameters.length === 0 && !types_1.ClassType.isBuiltIn(classType, 'type')) {
                 if (classType.details.baseClasses.some((baseClass) => (0, types_1.isInstantiableClass)(baseClass) && types_1.ClassType.hasCustomClassGetItem(baseClass)) ||
                     classType.details.fields.has('__class_getitem__')) {
-                    classType.details.flags |= 262144 /* ClassTypeFlags.HasCustomClassGetItem */;
+                    classType.details.flags |= 524288 /* ClassTypeFlags.HasCustomClassGetItem */;
                 }
             }
             // Determine the effective metaclass.
@@ -11711,17 +11722,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     classType.details.declaredMetaclass = metaclassType;
                     if ((0, types_1.isInstantiableClass)(metaclassType)) {
                         if ((0, enums_1.isEnumMetaclass)(metaclassType)) {
-                            classType.details.flags |= 1048576 /* ClassTypeFlags.EnumClass */;
+                            classType.details.flags |= 2097152 /* ClassTypeFlags.EnumClass */;
                         }
                         if (types_1.ClassType.isBuiltIn(metaclassType, 'ABCMeta')) {
-                            classType.details.flags |= 1024 /* ClassTypeFlags.SupportsAbstractMethods */;
+                            classType.details.flags |= 2048 /* ClassTypeFlags.SupportsAbstractMethods */;
                         }
                     }
                 }
             }
             const effectiveMetaclass = computeEffectiveMetaclass(classType, node.name);
             // Clear the "partially constructed" flag.
-            classType.details.flags &= ~131072 /* ClassTypeFlags.PartiallyEvaluated */;
+            classType.details.flags &= ~262144 /* ClassTypeFlags.PartiallyEvaluated */;
             // Now determine the decorated type of the class.
             let decoratedType = classType;
             let foundUnknown = false;
@@ -11783,7 +11794,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (foundInvalidBaseClass) {
                     addError(localize_1.LocMessage.typedDictBaseClass() + diag.getString(), node.name);
                 }
-                (0, typedDicts_1.synthesizeTypedDictClassMethods)(evaluatorInterface, node, classType, (0, types_1.isClass)(decoratedType) && types_1.ClassType.isFinal(decoratedType));
+                (0, typedDicts_1.synthesizeTypedDictClassMethods)(evaluatorInterface, node, classType);
             }
             // Synthesize dataclass methods.
             if (types_1.ClassType.isDataClass(classType)) {
@@ -12239,7 +12250,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;
@@ -12454,8 +12467,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (index >= firstNonClsSelfParamIndex) {
                 let isImplicitPositionOnlyParam = false;
                 if (param.category === 0 /* ParameterCategory.Simple */ && param.name) {
-                    if ((0, symbolNameUtils_1.isPrivateName)(param.name.value)) {
+                    if ((0, symbolNameUtils_1.isPrivateName)(param.name.value) &&
+                        !node.parameters.some((p) => p.category === 0 /* ParameterCategory.Simple */ && !p.name)) {
                         isImplicitPositionOnlyParam = true;
+                        // If the parameter name indicates an implicit position-only parameter
+                        // but we have already seen non-position-only parameters, report an error.
+                        if (!paramsArePositionOnly &&
+                            functionType.details.parameters.every((p) => p.category === 0 /* ParameterCategory.Simple */)) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.positionOnlyAfterNon(), param.name);
+                        }
                     }
                 }
                 else {
@@ -12750,11 +12770,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.
@@ -13978,7 +13994,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 case 'Concatenate': {
                     return { type: createConcatenateType(classType, errorNode, typeArgs, flags) };
                 }
-                case 'TypeGuard': {
+                case 'TypeGuard':
+                case 'TypeIs': {
                     return { type: createTypeGuardType(classType, errorNode, typeArgs, flags) };
                 }
                 case 'Unpack': {
@@ -14525,7 +14542,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // is a valid entry in the TypedDict to avoid resolving declarations for
                 // synthesized symbols such as 'get'.
                 if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isTypedDictClass(subtype)) {
-                    const entry = (_a = subtype.details.typedDictEntries) === null || _a === void 0 ? void 0 : _a.get(node.value);
+                    const entry = (_a = subtype.details.typedDictEntries) === null || _a === void 0 ? void 0 : _a.knownItems.get(node.value);
                     if (entry) {
                         const symbol = (_b = (0, typeUtils_1.lookUpObjectMember)(subtype, node.value)) === null || _b === void 0 ? void 0 : _b.symbol;
                         if (symbol) {
@@ -14826,7 +14843,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')) {
@@ -14891,7 +14910,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             else {
-                const boundType = getTypeOfExpressionExpectingType(node.boundExpression).type;
+                const boundType = getTypeOfExpressionExpectingType(node.boundExpression, {
+                    disallowProtocolAndTypedDict: true,
+                }).type;
                 if ((0, typeUtils_1.requiresSpecialization)(boundType, { ignorePseudoGeneric: true })) {
                     addError(localize_1.LocMessage.typeVarConstraintGeneric(), node.boundExpression);
                 }
@@ -15081,9 +15102,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;
@@ -15838,26 +15861,66 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // Handle typed dicts. They also use a form of structural typing for type
         // checking, as defined in PEP 589.
-        if (types_1.ClassType.isTypedDictClass(destType) &&
-            types_1.ClassType.isTypedDictClass(srcType) &&
-            !types_1.ClassType.isSameGenericClass(destType, srcType)) {
-            if (!(0, typedDicts_1.assignTypedDictToTypedDict)(evaluatorInterface, destType, srcType, diag, destTypeVarContext, flags, recursionCount)) {
-                return false;
+        if (types_1.ClassType.isTypedDictClass(srcType)) {
+            if (types_1.ClassType.isTypedDictClass(destType) && !types_1.ClassType.isSameGenericClass(destType, srcType)) {
+                if (!(0, typedDicts_1.assignTypedDictToTypedDict)(evaluatorInterface, destType, srcType, diag, destTypeVarContext, flags, recursionCount)) {
+                    return false;
+                }
+                if (types_1.ClassType.isFinal(destType) !== types_1.ClassType.isFinal(srcType)) {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typedDictFinalMismatch().format({
+                        sourceType: printType((0, typeUtils_1.convertToInstance)(srcType)),
+                        destType: printType((0, typeUtils_1.convertToInstance)(destType)),
+                    }));
+                    return false;
+                }
+                // If invariance is being enforced, the two TypedDicts must be assignable to each other.
+                if ((flags & 1 /* AssignTypeFlags.EnforceInvariance */) !== 0) {
+                    return (0, typedDicts_1.assignTypedDictToTypedDict)(evaluatorInterface, srcType, destType, 
+                    /* diag */ undefined, 
+                    /* typeVarContext */ undefined, flags, recursionCount);
+                }
+                return true;
             }
-            if (types_1.ClassType.isFinal(destType) !== types_1.ClassType.isFinal(srcType)) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typedDictFinalMismatch().format({
-                    sourceType: printType((0, typeUtils_1.convertToInstance)(srcType)),
-                    destType: printType((0, typeUtils_1.convertToInstance)(destType)),
-                }));
-                return false;
+            // Handle some special cases where a TypedDict can act like
+            // a Mapping[str, T] or a dict[str, T].
+            if (types_1.ClassType.isBuiltIn(destType, 'Mapping')) {
+                const mappingValueType = (0, typedDicts_1.getTypedDictMappingEquivalent)(evaluatorInterface, srcType);
+                if (mappingValueType &&
+                    mappingType &&
+                    (0, types_1.isInstantiableClass)(mappingType) &&
+                    strClassType &&
+                    (0, types_1.isInstantiableClass)(strClassType)) {
+                    srcType = types_1.ClassType.cloneForSpecialization(mappingType, [types_1.ClassType.cloneAsInstance(strClassType), mappingValueType], 
+                    /* isTypeArgumentExplicit */ true);
+                }
             }
-            // If invariance is being enforced, the two TypedDicts must be assignable to each other.
-            if ((flags & 1 /* AssignTypeFlags.EnforceInvariance */) !== 0) {
-                return (0, typedDicts_1.assignTypedDictToTypedDict)(evaluatorInterface, srcType, destType, 
-                /* diag */ undefined, 
-                /* typeVarContext */ undefined, flags, recursionCount);
+            else if (types_1.ClassType.isBuiltIn(destType, ['dict', 'MutableMapping'])) {
+                const dictValueType = (0, typedDicts_1.getTypedDictDictEquivalent)(evaluatorInterface, srcType, recursionCount);
+                if (dictValueType &&
+                    dictClassType &&
+                    (0, types_1.isInstantiableClass)(dictClassType) &&
+                    strClassType &&
+                    (0, types_1.isInstantiableClass)(strClassType)) {
+                    srcType = types_1.ClassType.cloneForSpecialization(dictClassType, [types_1.ClassType.cloneAsInstance(strClassType), dictValueType], 
+                    /* isTypeArgumentExplicit */ true);
+                }
+            }
+        }
+        // See if the dest type is a TypedDict class and the source is a compatible dict.
+        if (types_1.ClassType.isTypedDictClass(destType) && types_1.ClassType.isBuiltIn(srcType, 'dict')) {
+            if (srcType.typeArguments &&
+                srcType.typeArguments.length === 2 &&
+                (0, types_1.isClassInstance)(srcType.typeArguments[0]) &&
+                types_1.ClassType.isBuiltIn(srcType.typeArguments[0], 'str')) {
+                const dictValueType = (0, typedDicts_1.getTypedDictDictEquivalent)(evaluatorInterface, destType, recursionCount);
+                if (dictValueType &&
+                    assignType(dictValueType, srcType.typeArguments[1], 
+                    /* diag */ undefined, 
+                    /* destTypeVarContext */ undefined, 
+                    /* srcTypeVarContext */ undefined, 1 /* AssignTypeFlags.EnforceInvariance */, recursionCount + 1)) {
+                    return true;
+                }
             }
-            return true;
         }
         // Handle special-case type promotions.
         if (destType.includePromotions) {
@@ -16039,26 +16102,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const destUnboundedOrVariadicIndex = destTypeArgs.findIndex((t) => t.isUnbounded || (0, types_1.isVariadicTypeVar)(t.type));
         const srcUnboundedIndex = srcTypeArgs.findIndex((t) => t.isUnbounded);
         const srcVariadicIndex = srcTypeArgs.findIndex((t) => (0, types_1.isVariadicTypeVar)(t.type));
-        let isSrcVariadicAny = false;
-        // If the src contains an unbounded type but the dest does not, it's incompatible.
-        if (srcUnboundedIndex >= 0 && destUnboundedOrVariadicIndex < 0) {
-            // Unless the source contains an [Any, ...].
+        if (srcUnboundedIndex >= 0) {
             if ((0, types_1.isAnyOrUnknown)(srcTypeArgs[srcUnboundedIndex].type)) {
-                isSrcVariadicAny = true;
+                // If the source contains an unbounded Any, expand it to match the dest length.
+                const typeToReplicate = srcTypeArgs.length > 0 ? srcTypeArgs[srcUnboundedIndex].type : types_1.AnyType.create();
+                while (srcTypeArgs.length < destTypeArgs.length) {
+                    srcTypeArgs.splice(srcUnboundedIndex, 0, { type: typeToReplicate, isUnbounded: true });
+                }
+                if (srcTypeArgs.length > destTypeArgs.length) {
+                    srcTypeArgs.splice(srcUnboundedIndex, 1);
+                }
             }
-            else {
+            else if (destUnboundedOrVariadicIndex < 0) {
+                // If the source contains an unbounded type but the dest does not, it's incompatible.
                 return false;
             }
         }
-        if (srcUnboundedIndex >= 0) {
-            // The source is unbounded, so expand the unbounded argument to try
-            // to make the source and dest arg counts match.
-            const typeToReplicate = srcTypeArgs.length > 0 ? srcTypeArgs[srcUnboundedIndex].type : types_1.AnyType.create();
-            while (srcTypeArgs.length < destTypeArgs.length) {
-                srcTypeArgs.splice(srcUnboundedIndex, 0, { type: typeToReplicate, isUnbounded: true });
-            }
-            if (isSrcVariadicAny && srcTypeArgs.length > destTypeArgs.length) {
-                srcTypeArgs.splice(srcUnboundedIndex, 1);
+        // If the dest contains an unbounded Any, expand it to match the source length.
+        if (destUnboundedOrVariadicIndex >= 0 &&
+            destTypeArgs[destUnboundedOrVariadicIndex].isUnbounded &&
+            (0, types_1.isAnyOrUnknown)(destTypeArgs[destUnboundedOrVariadicIndex].type)) {
+            while (destTypeArgs.length < srcTypeArgs.length) {
+                destTypeArgs.splice(destUnboundedOrVariadicIndex, 0, destTypeArgs[destUnboundedOrVariadicIndex]);
             }
         }
         // Remove any optional parameters from the end of the two lists until the lengths match.
@@ -16068,23 +16133,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         while (destTypeArgs.length > srcTypeArgs.length && destTypeArgs[destTypeArgs.length - 1].isOptional) {
             destTypeArgs.splice(destTypeArgs.length - 1, 1);
         }
-        if (srcVariadicIndex >= 0) {
+        // If we're doing reverse type mappings and the source contains a variadic
+        // TypeVar, we need to adjust the dest so the reverse type mapping assignment
+        // can be performed.
+        if ((flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) !== 0) {
             const destArgsToCapture = destTypeArgs.length - srcTypeArgs.length + 1;
-            // If we're doing reverse type mappings and the source contains a variadic
-            // TypeVar, we need to adjust the dest so the reverse type mapping assignment
-            // can be performed.
-            if (destArgsToCapture >= 0 && (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) !== 0) {
+            if (srcVariadicIndex >= 0 && destArgsToCapture >= 0) {
                 // If the only removed arg from the dest type args is itself a variadic,
                 // don't bother adjusting it.
                 const skipAdjustment = destArgsToCapture === 1 && (0, types_1.isVariadicTypeVar)(destTypeArgs[srcVariadicIndex].type);
                 if (!skipAdjustment && tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
                     const removedArgs = destTypeArgs.splice(srcVariadicIndex, destArgsToCapture);
                     // Package up the remaining type arguments into a tuple object.
-                    const variadicTuple = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, removedArgs.map((typeArg) => {
-                        return { type: typeArg.type, isUnbounded: typeArg.isUnbounded };
+                    const variadicTuple = makeTupleObject(removedArgs.map((typeArg) => {
+                        return {
+                            type: typeArg.type,
+                            isUnbounded: typeArg.isUnbounded,
+                            isOptional: typeArg.isOptional,
+                        };
                     }), 
-                    /* isTypeArgumentExplicit */ true, 
-                    /* isUnpackedTuple */ true));
+                    /* isUnpackedTuple */ true);
                     destTypeArgs.splice(srcVariadicIndex, 0, {
                         type: variadicTuple,
                         isUnbounded: false,
@@ -16101,11 +16169,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
                         const removedArgs = srcTypeArgs.splice(destUnboundedOrVariadicIndex, srcArgsToCapture);
                         // Package up the remaining type arguments into a tuple object.
-                        const variadicTuple = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, removedArgs.map((typeArg) => {
-                            return { type: typeArg.type, isUnbounded: typeArg.isUnbounded };
+                        const variadicTuple = makeTupleObject(removedArgs.map((typeArg) => {
+                            return {
+                                type: typeArg.type,
+                                isUnbounded: typeArg.isUnbounded,
+                                isOptional: typeArg.isOptional,
+                            };
                         }), 
-                        /* isTypeArgumentExplicit */ true, 
-                        /* isUnpackedTuple */ true));
+                        /* isUnpackedTuple */ true);
                         srcTypeArgs.splice(destUnboundedOrVariadicIndex, 0, {
                             type: variadicTuple,
                             isUnbounded: false,
@@ -16113,18 +16184,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 else {
-                    const removedArgTypes = srcTypeArgs
-                        .splice(destUnboundedOrVariadicIndex, srcArgsToCapture)
-                        .map((t) => {
-                        if ((0, types_1.isTypeVar)(t.type) && (0, types_1.isUnpackedVariadicTypeVar)(t.type) && !t.type.isVariadicInUnion) {
-                            return types_1.TypeVarType.cloneForUnpacked(t.type, /* isInUnion */ true);
-                        }
-                        return t.type;
-                    });
-                    srcTypeArgs.splice(destUnboundedOrVariadicIndex, 0, {
-                        type: removedArgTypes.length > 0 ? (0, types_1.combineTypes)(removedArgTypes) : types_1.AnyType.create(),
-                        isUnbounded: false,
-                    });
+                    // If possible, package up the source entries that correspond to
+                    // the dest unbounded tuple. This isn't possible if the source contains
+                    // an unbounded tuple outside of this range.
+                    if (srcUnboundedIndex < 0 ||
+                        (srcUnboundedIndex >= destUnboundedOrVariadicIndex &&
+                            srcUnboundedIndex < destUnboundedOrVariadicIndex + srcArgsToCapture)) {
+                        const removedArgTypes = srcTypeArgs
+                            .splice(destUnboundedOrVariadicIndex, srcArgsToCapture)
+                            .map((t) => {
+                            if ((0, types_1.isTypeVar)(t.type) &&
+                                (0, types_1.isUnpackedVariadicTypeVar)(t.type) &&
+                                !t.type.isVariadicInUnion) {
+                                return types_1.TypeVarType.cloneForUnpacked(t.type, /* isInUnion */ true);
+                            }
+                            return t.type;
+                        });
+                        srcTypeArgs.splice(destUnboundedOrVariadicIndex, 0, {
+                            type: removedArgTypes.length > 0 ? (0, types_1.combineTypes)(removedArgTypes) : types_1.AnyType.create(),
+                            isUnbounded: false,
+                        });
+                    }
                 }
             }
         }
@@ -16148,16 +16228,32 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         else {
-            if (srcTypeArgs.find((t) => t.isUnbounded)) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.tupleSizeIndeterminate().format({
-                    expected: destTypeArgs.length,
-                }));
+            const isDestIndeterminate = destTypeArgs.some((t) => t.isUnbounded || (0, types_1.isVariadicTypeVar)(t.type));
+            if (srcTypeArgs.some((t) => t.isUnbounded || (0, types_1.isVariadicTypeVar)(t.type))) {
+                if (isDestIndeterminate) {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.tupleSizeIndeterminateSrcDest().format({
+                        expected: destTypeArgs.length - 1,
+                    }));
+                }
+                else {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.tupleSizeIndeterminateSrc().format({
+                        expected: destTypeArgs.length,
+                    }));
+                }
             }
             else {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.tupleSizeMismatch().format({
-                    expected: destTypeArgs.length,
-                    received: srcTypeArgs.length,
-                }));
+                if (isDestIndeterminate) {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.tupleSizeMismatchIndeterminateDest().format({
+                        expected: destTypeArgs.length - 1,
+                        received: srcTypeArgs.length,
+                    }));
+                }
+                else {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.tupleSizeMismatch().format({
+                        expected: destTypeArgs.length,
+                        received: srcTypeArgs.length,
+                    }));
+                }
             }
             return false;
         }
@@ -16248,6 +16344,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);
             }
         }
@@ -16595,7 +16692,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if ((0, types_1.isNever)(srcType)) {
             if ((flags & 1 /* AssignTypeFlags.EnforceInvariance */) !== 0) {
-                return (0, types_1.isNever)(destType);
+                if ((0, types_1.isNever)(destType)) {
+                    return true;
+                }
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
+                return false;
             }
             const targetTypeVarContext = (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) === 0 ? destTypeVarContext : srcTypeVarContext;
             if (targetTypeVarContext) {
@@ -16728,7 +16829,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return !isLiteral;
                 }
             }
-            else if (types_1.ClassType.isBuiltIn(destType, 'TypeGuard')) {
+            else if (types_1.ClassType.isBuiltIn(destType, ['TypeGuard', 'TypeIs'])) {
                 // All the source to be a "bool".
                 if ((originalFlags & 128 /* AssignTypeFlags.AllowBoolTypeGuard */) !== 0) {
                     if ((0, types_1.isClassInstance)(srcType) && types_1.ClassType.isBuiltIn(srcType, 'bool')) {
@@ -17010,7 +17111,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return false;
                 });
                 if (destTypeIndex >= 0) {
-                    if (assignType(remainingDestSubtypes[destTypeIndex], srcSubtype, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+                    if (assignType(remainingDestSubtypes[destTypeIndex], srcSubtype, 
+                    /* diag */ undefined, destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
                         // Note that we have matched at least one subtype indicating
                         // there is at least some overlap.
                         matchedSomeSubtypes = true;
@@ -17459,15 +17561,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         });
         if (srcTupleTypes.length !== 1 || !(0, types_1.isVariadicTypeVar)(srcTupleTypes[0].type)) {
-            let srcPositionalsType;
-            if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
-                srcPositionalsType = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, srcTupleTypes, 
-                /* isTypeArgumentExplicit */ true, 
-                /* isUnpackedTuple */ true));
-            }
-            else {
-                srcPositionalsType = types_1.UnknownType.create();
-            }
+            const srcPositionalsType = makeTupleObject(srcTupleTypes, /* isUnpackedTuple */ true);
             // Snip out the portion of the source positionals that map to the variadic
             // dest parameter and replace it with a single parameter that is typed as a
             // tuple containing the individual types of the replaced parameters.
@@ -17675,15 +17769,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;
@@ -17917,10 +18007,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     isReturnTypeCompatible = true;
                 }
                 else {
-                    // Handle the special case where the return type is a TypeGuard[T].
-                    // This should also act as a bool, since that's its type at runtime.
+                    // Handle the special case where the return type is a TypeGuard[T]
+                    // or TypeIs[T]. This should also act as a bool, since that's its
+                    // type at runtime.
                     if ((0, types_1.isClassInstance)(srcReturnType) &&
-                        types_1.ClassType.isBuiltIn(srcReturnType, 'TypeGuard') &&
+                        types_1.ClassType.isBuiltIn(srcReturnType, ['TypeGuard', 'TypeIs']) &&
                         boolClassType &&
                         (0, types_1.isInstantiableClass)(boolClassType)) {
                         if (assignType(destReturnType, types_1.ClassType.cloneAsInstance(boolClassType), returnDiag === null || returnDiag === void 0 ? void 0 : returnDiag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
@@ -18012,6 +18103,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)) {