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

package/dist/analyzer/typedDicts.js

@@ -32,7 +32,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.narrowForKeyAssignment = exports.getTypeOfIndexedTypedDict = exports.assignToTypedDict = exports.assignTypedDictToTypedDict = exports.getTypedDictMembersForClass = exports.synthesizeTypedDictClassMethods = exports.createTypedDictTypeInlined = exports.createTypedDictType = void 0;
+exports.narrowForKeyAssignment = exports.getTypeOfIndexedTypedDict = exports.assignToTypedDict = exports.assignTypedDictToTypedDict = exports.getEffectiveExtraItemsEntryType = exports.getTypedDictDictEquivalent = exports.getTypedDictMappingEquivalent = exports.getTypedDictMembersForClass = exports.synthesizeTypedDictClassMethods = exports.createTypedDictTypeInlined = exports.createTypedDictType = void 0;
 const collectionUtils_1 = require("../common/collectionUtils");
 const debug_1 = require("../common/debug");
 const diagnostic_1 = require("../common/diagnostic");
@@ -49,7 +49,7 @@ const typeUtils_1 = require("./typeUtils");
 const typeVarContext_1 = require("./typeVarContext");
 // Creates a new custom TypedDict "alternate syntax" factory class.
 function createTypedDictType(evaluator, errorNode, typedDictClass, argList) {
-    var _a, _b;
+    var _a, _b, _c;
     const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
     // TypedDict supports two different syntaxes:
     // Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': str})
@@ -70,7 +70,7 @@ function createTypedDictType(evaluator, errorNode, typedDictClass, argList) {
         }
     }
     const effectiveClassName = className || 'TypedDict';
-    const classType = types_1.ClassType.createInstantiable(effectiveClassName, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, effectiveClassName), fileInfo.moduleName, fileInfo.fileUri, 128 /* ClassTypeFlags.TypedDictClass */ | 536870912 /* ClassTypeFlags.ValidTypeAliasClass */, ParseTreeUtils.getTypeSourceId(errorNode), 
+    const classType = types_1.ClassType.createInstantiable(effectiveClassName, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, effectiveClassName), fileInfo.moduleName, fileInfo.fileUri, 128 /* ClassTypeFlags.TypedDictClass */ | 1073741824 /* ClassTypeFlags.ValidTypeAliasClass */, ParseTreeUtils.getTypeSourceId(errorNode), 
     /* declaredMetaclass */ undefined, typedDictClass.details.effectiveMetaclass);
     classType.details.baseClasses.push(typedDictClass);
     (0, typeUtils_1.computeMroLinearization)(classType);
@@ -122,7 +122,7 @@ function createTypedDictType(evaluator, errorNode, typedDictClass, argList) {
     }
     if (usingDictSyntax) {
         for (const arg of argList.slice(2)) {
-            if (((_a = arg.name) === null || _a === void 0 ? void 0 : _a.value) === 'total') {
+            if (((_a = arg.name) === null || _a === void 0 ? void 0 : _a.value) === 'total' || ((_b = arg.name) === null || _b === void 0 ? void 0 : _b.value) === 'closed') {
                 if (!arg.valueExpression ||
                     arg.valueExpression.nodeType !== 11 /* ParseNodeType.Constant */ ||
                     !(arg.valueExpression.constType === 15 /* KeywordType.False */ ||
@@ -130,7 +130,13 @@ function createTypedDictType(evaluator, errorNode, typedDictClass, argList) {
                     evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictBoolParam().format({ name: arg.name.value }), arg.valueExpression || errorNode);
                 }
                 else if (arg.name.value === 'total' && arg.valueExpression.constType === 15 /* KeywordType.False */) {
-                    classType.details.flags |= 256 /* ClassTypeFlags.CanOmitDictValues */;
+                    classType.details.flags |= 1024 /* ClassTypeFlags.CanOmitDictValues */;
+                }
+                else if (arg.name.value === 'closed' && arg.valueExpression.constType === 33 /* KeywordType.True */) {
+                    if (AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.enableExperimentalFeatures) {
+                        classType.details.flags |=
+                            256 /* ClassTypeFlags.TypedDictMarkedClosed */ | 512 /* ClassTypeFlags.TypedDictEffectivelyClosed */;
+                    }
                 }
             }
             else {
@@ -138,9 +144,9 @@ function createTypedDictType(evaluator, errorNode, typedDictClass, argList) {
             }
         }
     }
-    synthesizeTypedDictClassMethods(evaluator, errorNode, classType, /* isClassFinal */ false);
+    synthesizeTypedDictClassMethods(evaluator, errorNode, classType);
     // Validate that the assigned variable name is consistent with the provided name.
-    if (((_b = errorNode.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 3 /* ParseNodeType.Assignment */ && className) {
+    if (((_c = errorNode.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 3 /* ParseNodeType.Assignment */ && className) {
         const target = errorNode.parent.leftExpression;
         const typedDictTarget = target.nodeType === 54 /* ParseNodeType.TypeAnnotation */ ? target.valueExpression : target;
         if (typedDictTarget.nodeType === 38 /* ParseNodeType.Name */) {
@@ -163,11 +169,12 @@ function createTypedDictTypeInlined(evaluator, dictNode, typedDictClass) {
     classType.details.baseClasses.push(typedDictClass);
     (0, typeUtils_1.computeMroLinearization)(classType);
     getTypedDictFieldsFromDictSyntax(evaluator, dictNode, classType.details.fields, /* isInline */ true);
-    synthesizeTypedDictClassMethods(evaluator, dictNode, classType, /* isClassFinal */ true);
+    synthesizeTypedDictClassMethods(evaluator, dictNode, classType);
     return classType;
 }
 exports.createTypedDictTypeInlined = createTypedDictTypeInlined;
-function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFinal) {
+function synthesizeTypedDictClassMethods(evaluator, node, classType) {
+    var _a;
     (0, debug_1.assert)(types_1.ClassType.isTypedDictClass(classType));
     // Synthesize a __new__ method.
     const newType = types_1.FunctionType.createSynthesizedInstance('__new__', 1 /* FunctionTypeFlags.ConstructorMethod */);
@@ -209,9 +216,9 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFina
     // All parameters must be named, so insert an empty "*".
     types_1.FunctionType.addKeywordOnlyParameterSeparator(initOverride2);
     const entries = getTypedDictMembersForClass(evaluator, classType);
-    let allEntriesAreNotRequired = true;
-    let allEntriesAreReadOnly = true;
-    entries.forEach((entry, name) => {
+    const extraEntriesInfo = (_a = entries.extraItems) !== null && _a !== void 0 ? _a : getEffectiveExtraItemsEntryType(evaluator, classType);
+    let allEntriesAreReadOnly = entries.knownItems.size > 0;
+    entries.knownItems.forEach((entry, name) => {
         types_1.FunctionType.addParameter(initOverride1, {
             category: 0 /* ParameterCategory.Simple */,
             name,
@@ -226,13 +233,26 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFina
             type: entry.valueType,
             hasDeclaredType: true,
         });
-        if (entry.isRequired) {
-            allEntriesAreNotRequired = false;
-        }
         if (!entry.isReadOnly) {
             allEntriesAreReadOnly = false;
         }
     });
+    if (entries.extraItems && !(0, types_1.isNever)(entries.extraItems.valueType)) {
+        types_1.FunctionType.addParameter(initOverride1, {
+            category: 2 /* ParameterCategory.KwargsDict */,
+            name: 'kwargs',
+            hasDefault: false,
+            type: entries.extraItems.valueType,
+            hasDeclaredType: true,
+        });
+        types_1.FunctionType.addParameter(initOverride2, {
+            category: 2 /* ParameterCategory.KwargsDict */,
+            name: 'kwargs',
+            hasDefault: false,
+            type: entries.extraItems.valueType,
+            hasDeclaredType: true,
+        });
+    }
     const symbolTable = classType.details.fields;
     const initType = types_1.OverloadedFunctionType.create([initOverride1, initOverride2]);
     symbolTable.set('__init__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, initType));
@@ -389,7 +409,7 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFina
             updateMethod3.details.declaredReturnType = evaluator.getNoneType();
             const tuplesToCombine = [];
             const tupleClass = evaluator.getBuiltInType(node, 'tuple');
-            entries.forEach((entry, name) => {
+            entries.knownItems.forEach((entry, name) => {
                 if (!entry.isReadOnly) {
                     // For writable entries, add a tuple entry.
                     if (tupleClass && (0, types_1.isInstantiableClass)(tupleClass) && strClass && (0, types_1.isInstantiableClass)(strClass)) {
@@ -433,7 +453,7 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFina
         const getOverloads = [];
         const popOverloads = [];
         const setDefaultOverloads = [];
-        entries.forEach((entry, name) => {
+        entries.knownItems.forEach((entry, name) => {
             const nameLiteralType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneWithLiteral(strClass, name));
             getOverloads.push(createGetMethod(nameLiteralType, entry.valueType, /* includeDefault */ false, entry.isRequired));
             getOverloads.push(createGetMethod(nameLiteralType, entry.valueType, 
@@ -448,9 +468,9 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFina
                 setDefaultOverloads.push(createSetDefaultMethod(nameLiteralType, entry.valueType));
             }
         });
-        // If the class is marked "@final", we can assume that any other literal
+        // If the class is closed, we can assume that any other literal
         // key values will return the default parameter value.
-        if (isClassFinal) {
+        if (types_1.ClassType.isTypedDictEffectivelyClosed(classType) && (0, types_1.isNever)(extraEntriesInfo.valueType)) {
             const literalStringType = evaluator.getTypingType(node, 'LiteralString');
             if (literalStringType && (0, types_1.isInstantiableClass)(literalStringType)) {
                 const literalStringInstance = types_1.ClassType.cloneAsInstance(literalStringType);
@@ -476,9 +496,10 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFina
             symbolTable.set('__delitem__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, createDelItemMethod(strType)));
         }
         symbolTable.set('update', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, createUpdateMethod()));
-        // If the TypedDict is final and all of its entries are NotRequired,
-        // add a "clear" and "popitem" method.
-        if (isClassFinal && allEntriesAreNotRequired && !allEntriesAreReadOnly) {
+        // If the TypedDict is closed and all of its entries are NotRequired and
+        // not ReadOnly, add a "clear" and "popitem" method.
+        const dictValueType = getTypedDictDictEquivalent(evaluator, classType);
+        if (dictValueType) {
             const clearMethod = types_1.FunctionType.createSynthesizedInstance('clear');
             types_1.FunctionType.addParameter(clearMethod, selfParam);
             clearMethod.details.declaredReturnType = evaluator.getNoneType();
@@ -489,7 +510,7 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFina
             if (tupleType && (0, types_1.isInstantiableClass)(tupleType)) {
                 tupleType = (0, typeUtils_1.specializeTupleClass)(types_1.ClassType.cloneAsInstance(tupleType), [
                     { type: strType, isUnbounded: false },
-                    { type: types_1.UnknownType.create(), isUnbounded: false },
+                    { type: dictValueType, isUnbounded: false },
                 ], 
                 /* isTypeArgumentExplicit */ true);
             }
@@ -499,21 +520,50 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFina
             popItemMethod.details.declaredReturnType = tupleType;
             symbolTable.set('popitem', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, popItemMethod));
         }
+        // If the TypedDict is closed, we can provide a more accurate value type
+        // for the "items", "keys" and "values" methods.
+        const mappingValueType = getTypedDictMappingEquivalent(evaluator, classType);
+        if (mappingValueType) {
+            ['items', 'keys', 'values'].forEach((methodName) => {
+                const method = types_1.FunctionType.createSynthesizedInstance(methodName);
+                types_1.FunctionType.addParameter(method, selfParam);
+                const returnTypeClass = evaluator.getTypingType(node, `dict_${methodName}`);
+                if (returnTypeClass &&
+                    (0, types_1.isInstantiableClass)(returnTypeClass) &&
+                    returnTypeClass.details.typeParameters.length === 2) {
+                    method.details.declaredReturnType = types_1.ClassType.cloneForSpecialization(types_1.ClassType.cloneAsInstance(returnTypeClass), [strType, mappingValueType], 
+                    /* isTypeArgumentExplicit */ true);
+                    symbolTable.set(methodName, symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, method));
+                }
+            });
+        }
     }
 }
 exports.synthesizeTypedDictClassMethods = synthesizeTypedDictClassMethods;
 function getTypedDictMembersForClass(evaluator, classType, allowNarrowed = false) {
+    var _a;
     // Were the entries already calculated and cached?
     if (!classType.details.typedDictEntries) {
-        const entries = new Map();
+        const entries = {
+            knownItems: new Map(),
+            extraItems: undefined,
+        };
         getTypedDictMembersForClassRecursive(evaluator, classType, entries);
+        if (types_1.ClassType.isTypedDictMarkedClosed(classType) && !entries.extraItems) {
+            entries.extraItems = {
+                valueType: types_1.NeverType.createNever(),
+                isReadOnly: false,
+                isRequired: false,
+                isProvided: false,
+            };
+        }
         // Cache the entries for next time.
         classType.details.typedDictEntries = entries;
     }
     const typeVarContext = (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(classType);
     // Create a specialized copy of the entries so the caller can mutate them.
     const entries = new Map();
-    classType.details.typedDictEntries.forEach((value, key) => {
+    classType.details.typedDictEntries.knownItems.forEach((value, key) => {
         const tdEntry = { ...value };
         tdEntry.valueType = (0, typeUtils_1.applySolvedTypeVars)(tdEntry.valueType, typeVarContext);
         // If the class is "Partial", make all entries optional and convert all
@@ -537,9 +587,72 @@ function getTypedDictMembersForClass(evaluator, classType, allowNarrowed = false
             entries.set(key, tdEntry);
         });
     }
-    return entries;
+    return {
+        knownItems: entries,
+        extraItems: (_a = classType.details.typedDictEntries) === null || _a === void 0 ? void 0 : _a.extraItems,
+    };
 }
 exports.getTypedDictMembersForClass = getTypedDictMembersForClass;
+// If the TypedDict class is consistent with Mapping[str, T] where T
+// is some type other than object, it returns T. Otherwise it returns undefined.
+function getTypedDictMappingEquivalent(evaluator, classType) {
+    (0, debug_1.assert)((0, types_1.isInstantiableClass)(classType));
+    (0, debug_1.assert)(types_1.ClassType.isTypedDictClass(classType));
+    // If the TypedDict class isn't closed, it's just a normal Mapping[str, object].
+    if (!types_1.ClassType.isTypedDictEffectivelyClosed(classType)) {
+        return undefined;
+    }
+    const entries = getTypedDictMembersForClass(evaluator, classType);
+    const typesToCombine = [];
+    entries.knownItems.forEach((entry) => {
+        typesToCombine.push(entry.valueType);
+    });
+    if (entries.extraItems) {
+        typesToCombine.push(entries.extraItems.valueType);
+    }
+    // Is the final value type 'object'?
+    const valueType = (0, types_1.combineTypes)(typesToCombine);
+    if ((0, types_1.isClassInstance)(valueType) && types_1.ClassType.isBuiltIn(valueType, 'object')) {
+        return undefined;
+    }
+    return valueType;
+}
+exports.getTypedDictMappingEquivalent = getTypedDictMappingEquivalent;
+// If the TypedDict class is consistent with dict[str, T], it returns T.
+// Otherwise it returns undefined.
+function getTypedDictDictEquivalent(evaluator, classType, recursionCount = 0) {
+    (0, debug_1.assert)((0, types_1.isInstantiableClass)(classType));
+    (0, debug_1.assert)(types_1.ClassType.isTypedDictClass(classType));
+    // If the TypedDict class isn't closed, it's not equivalent to a dict.
+    if (!types_1.ClassType.isTypedDictEffectivelyClosed(classType)) {
+        return undefined;
+    }
+    const entries = getTypedDictMembersForClass(evaluator, classType);
+    // If there is no "extraItems" defined or it is read-only, it's not
+    // equivalent to a dict.
+    if (!entries.extraItems || entries.extraItems.isReadOnly) {
+        return undefined;
+    }
+    let dictValueType = entries.extraItems.valueType;
+    let isEquivalentToDict = true;
+    entries.knownItems.forEach((entry) => {
+        if (entry.isReadOnly || entry.isRequired) {
+            isEquivalentToDict = false;
+        }
+        dictValueType = (0, types_1.combineTypes)([dictValueType, entry.valueType]);
+        if (!evaluator.assignType(dictValueType, entry.valueType, 
+        /* diag */ undefined, 
+        /* destTypeVarContext */ undefined, 
+        /* srcTypeVarContext */ undefined, 1 /* AssignTypeFlags.EnforceInvariance */, recursionCount + 1)) {
+            isEquivalentToDict = false;
+        }
+    });
+    if (!isEquivalentToDict) {
+        return undefined;
+    }
+    return dictValueType;
+}
+exports.getTypedDictDictEquivalent = getTypedDictDictEquivalent;
 function getTypedDictFieldsFromDictSyntax(evaluator, entryDict, classFields, isInline) {
     const entrySet = new Set();
     const fileInfo = AnalyzerNodeInfo.getFileInfo(entryDict);
@@ -581,7 +694,7 @@ function getTypedDictFieldsFromDictSyntax(evaluator, entryDict, classFields, isI
     // get evaluated again.
     evaluator.setTypeResultForNode(entryDict, { type: types_1.UnknownType.create() });
 }
-function getTypedDictMembersForClassRecursive(evaluator, classType, keyMap, recursionCount = 0) {
+function getTypedDictMembersForClassRecursive(evaluator, classType, entries, recursionCount = 0) {
     (0, debug_1.assert)(types_1.ClassType.isTypedDictClass(classType));
     if (recursionCount > types_1.maxTypeRecursionCount) {
         return;
@@ -593,7 +706,7 @@ function getTypedDictMembersForClassRecursive(evaluator, classType, keyMap, recu
             (0, debug_1.assert)((0, types_1.isClass)(specializedBaseClassType));
             // Recursively gather keys from parent classes. Don't report any errors
             // in these cases because they will be reported within that class.
-            getTypedDictMembersForClassRecursive(evaluator, specializedBaseClassType, keyMap, recursionCount);
+            getTypedDictMembersForClassRecursive(evaluator, specializedBaseClassType, entries, recursionCount);
         }
     });
     const typeVarContext = (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(classType);
@@ -605,48 +718,79 @@ function getTypedDictMembersForClassRecursive(evaluator, classType, keyMap, recu
             if (lastDecl && lastDecl.type === 1 /* DeclarationType.Variable */) {
                 let valueType = evaluator.getEffectiveTypeOfSymbol(symbol);
                 valueType = (0, typeUtils_1.applySolvedTypeVars)(valueType, typeVarContext);
+                const allowRequired = !types_1.ClassType.isTypedDictMarkedClosed(classType) || name !== '__extra_items__';
                 let isRequired = !types_1.ClassType.isCanOmitDictValues(classType);
                 let isReadOnly = false;
-                if (isRequiredTypedDictVariable(evaluator, symbol)) {
+                if (isRequiredTypedDictVariable(evaluator, symbol, allowRequired)) {
                     isRequired = true;
                 }
-                else if (isNotRequiredTypedDictVariable(evaluator, symbol)) {
+                else if (isNotRequiredTypedDictVariable(evaluator, symbol, allowRequired)) {
                     isRequired = false;
                 }
                 if (isReadOnlyTypedDictVariable(evaluator, symbol)) {
                     isReadOnly = true;
                 }
-                keyMap.set(name, {
+                const tdEntry = {
                     valueType,
                     isReadOnly,
                     isRequired,
                     isProvided: false,
-                });
+                };
+                if (types_1.ClassType.isTypedDictMarkedClosed(classType) && name === '__extra_items__') {
+                    tdEntry.isRequired = false;
+                    entries.extraItems = tdEntry;
+                }
+                else {
+                    entries.knownItems.set(name, tdEntry);
+                }
             }
         }
     });
 }
+function getEffectiveExtraItemsEntryType(evaluator, classType) {
+    var _a;
+    (0, debug_1.assert)(types_1.ClassType.isTypedDictClass(classType));
+    // Missing entries in a non-closed TypedDict class are implicitly typed as
+    // ReadOnly[NotRequired[object]].
+    if (!types_1.ClassType.isTypedDictMarkedClosed(classType)) {
+        return {
+            valueType: evaluator.getObjectType(),
+            isReadOnly: true,
+            isRequired: false,
+            isProvided: false,
+        };
+    }
+    if ((_a = classType.details.typedDictEntries) === null || _a === void 0 ? void 0 : _a.extraItems) {
+        return classType.details.typedDictEntries.extraItems;
+    }
+    return {
+        valueType: types_1.NeverType.createNever(),
+        isReadOnly: true,
+        isRequired: false,
+        isProvided: false,
+    };
+}
+exports.getEffectiveExtraItemsEntryType = getEffectiveExtraItemsEntryType;
 function assignTypedDictToTypedDict(evaluator, destType, srcType, diag, typeVarContext, flags, recursionCount = 0) {
+    var _a, _b;
     let typesAreConsistent = true;
     const destEntries = getTypedDictMembersForClass(evaluator, destType);
     const srcEntries = getTypedDictMembersForClass(evaluator, srcType, /* allowNarrowed */ true);
-    destEntries.forEach((destEntry, name) => {
-        const srcEntry = srcEntries.get(name);
+    const extraSrcEntries = (_a = srcEntries.extraItems) !== null && _a !== void 0 ? _a : getEffectiveExtraItemsEntryType(evaluator, srcType);
+    destEntries.knownItems.forEach((destEntry, name) => {
+        const srcEntry = srcEntries.knownItems.get(name);
         if (!srcEntry) {
             if (destEntry.isRequired || !destEntry.isReadOnly) {
                 diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.typedDictFieldMissing().format({
                     name,
-                    type: evaluator.printType(srcType),
+                    type: evaluator.printType(types_1.ClassType.cloneAsInstance(srcType)),
                 }));
                 typesAreConsistent = false;
             }
             else {
-                // Missing entries are implicitly typed as ReadOnly[NotRequired[object]],
-                // so we need to make sure the dest entry is compatible with that.
-                const objType = evaluator.getObjectType();
-                if ((0, types_1.isClassInstance)(objType)) {
+                if ((0, types_1.isClassInstance)(extraSrcEntries.valueType)) {
                     const subDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
-                    if (!evaluator.assignType(destEntry.valueType, objType, subDiag === null || subDiag === void 0 ? void 0 : subDiag.createAddendum(), typeVarContext, 
+                    if (!evaluator.assignType(destEntry.valueType, extraSrcEntries.valueType, subDiag === null || subDiag === void 0 ? void 0 : subDiag.createAddendum(), typeVarContext, 
                     /* srcTypeVarContext */ undefined, flags, recursionCount)) {
                         subDiag === null || subDiag === void 0 ? void 0 : subDiag.addMessage(localize_1.LocAddendum.memberTypeMismatch().format({ name }));
                         typesAreConsistent = false;
@@ -661,30 +805,85 @@ function assignTypedDictToTypedDict(evaluator, destType, srcType, diag, typeVarC
                     : localize_1.LocAddendum.typedDictFieldNotRequired();
                 diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(message.format({
                     name,
-                    type: evaluator.printType(destType),
+                    type: evaluator.printType(types_1.ClassType.cloneAsInstance(destType)),
                 }));
                 typesAreConsistent = false;
             }
             if (!destEntry.isReadOnly && srcEntry.isReadOnly) {
                 diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.typedDictFieldNotReadOnly().format({
                     name,
-                    type: evaluator.printType(destType),
+                    type: evaluator.printType(types_1.ClassType.cloneAsInstance(destType)),
                 }));
                 typesAreConsistent = false;
             }
             const subDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
-            let adjustedFlags = flags;
-            // If the dest field is not read-only, we need to enforce invariance.
-            if (!destEntry.isReadOnly) {
-                adjustedFlags |= 1 /* AssignTypeFlags.EnforceInvariance */;
-            }
             if (!evaluator.assignType(destEntry.valueType, srcEntry.valueType, subDiag === null || subDiag === void 0 ? void 0 : subDiag.createAddendum(), typeVarContext, 
-            /* srcTypeVarContext */ undefined, adjustedFlags, recursionCount)) {
+            /* srcTypeVarContext */ undefined, destEntry.isReadOnly ? flags : flags | 1 /* AssignTypeFlags.EnforceInvariance */, recursionCount)) {
                 subDiag === null || subDiag === void 0 ? void 0 : subDiag.addMessage(localize_1.LocAddendum.memberTypeMismatch().format({ name }));
                 typesAreConsistent = false;
             }
         }
     });
+    // If the destination TypedDict is closed, check any extra entries in the source
+    // TypedDict to ensure that they don't violate the "extra items" type.
+    if (types_1.ClassType.isTypedDictEffectivelyClosed(destType)) {
+        const extraDestEntries = (_b = destEntries.extraItems) !== null && _b !== void 0 ? _b : getEffectiveExtraItemsEntryType(evaluator, destType);
+        srcEntries.knownItems.forEach((srcEntry, name) => {
+            // Have we already checked this item in the loop above?
+            if (destEntries.knownItems.has(name)) {
+                return;
+            }
+            if (!destEntries.extraItems) {
+                const subDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
+                subDiag === null || subDiag === void 0 ? void 0 : subDiag.addMessage(localize_1.LocAddendum.typedDictExtraFieldNotAllowed().format({
+                    name,
+                    type: evaluator.printType(types_1.ClassType.cloneAsInstance(destType)),
+                }));
+                typesAreConsistent = false;
+            }
+            else {
+                if (srcEntry.isRequired && !destEntries.extraItems.isReadOnly) {
+                    diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.typedDictFieldNotRequired().format({
+                        name,
+                        type: evaluator.printType(types_1.ClassType.cloneAsInstance(destType)),
+                    }));
+                    typesAreConsistent = false;
+                }
+                const subDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
+                if (!evaluator.assignType(destEntries.extraItems.valueType, srcEntry.valueType, subDiag === null || subDiag === void 0 ? void 0 : subDiag.createAddendum(), typeVarContext, 
+                /* srcTypeVarContext */ undefined, destEntries.extraItems.isReadOnly ? flags : flags | 1 /* AssignTypeFlags.EnforceInvariance */, recursionCount)) {
+                    subDiag === null || subDiag === void 0 ? void 0 : subDiag.addMessage(localize_1.LocAddendum.typedDictExtraFieldTypeMismatch().format({
+                        name,
+                        type: evaluator.printType(types_1.ClassType.cloneAsInstance(destType)),
+                    }));
+                    typesAreConsistent = false;
+                }
+                else if (!destEntries.extraItems.isReadOnly && srcEntry.isReadOnly) {
+                    diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.typedDictFieldNotReadOnly().format({
+                        name,
+                        type: evaluator.printType(types_1.ClassType.cloneAsInstance(srcType)),
+                    }));
+                    typesAreConsistent = false;
+                }
+            }
+        });
+        const subDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
+        if (!evaluator.assignType(extraDestEntries.valueType, extraSrcEntries.valueType, subDiag === null || subDiag === void 0 ? void 0 : subDiag.createAddendum(), typeVarContext, 
+        /* srcTypeVarContext */ undefined, extraDestEntries.isReadOnly ? flags : flags | 1 /* AssignTypeFlags.EnforceInvariance */, recursionCount)) {
+            subDiag === null || subDiag === void 0 ? void 0 : subDiag.addMessage(localize_1.LocAddendum.typedDictExtraFieldTypeMismatch().format({
+                name: '__extra_items__',
+                type: evaluator.printType(types_1.ClassType.cloneAsInstance(srcType)),
+            }));
+            typesAreConsistent = false;
+        }
+        else if (!extraDestEntries.isReadOnly && extraSrcEntries.isReadOnly) {
+            diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.typedDictFieldNotReadOnly().format({
+                name: '__extra_items__',
+                type: evaluator.printType(types_1.ClassType.cloneAsInstance(destType)),
+            }));
+            typesAreConsistent = false;
+        }
+    }
     return typesAreConsistent;
 }
 exports.assignTypedDictToTypedDict = assignTypedDictToTypedDict;
@@ -711,7 +910,7 @@ function assignToTypedDict(evaluator, classType, keyTypes, valueTypes, diagAdden
             /* isTypeArgumentExplicit */ false);
         }
     }
-    const symbolMap = getTypedDictMembersForClass(evaluator, genericClassType);
+    const tdEntries = getTypedDictMembersForClass(evaluator, genericClassType);
     keyTypes.forEach((keyTypeResult, index) => {
         const keyType = keyTypeResult.type;
         if (!(0, types_1.isClassInstance)(keyType) || !types_1.ClassType.isBuiltIn(keyType, 'str') || !(0, typeUtils_1.isLiteralType)(keyType)) {
@@ -719,17 +918,33 @@ function assignToTypedDict(evaluator, classType, keyTypes, valueTypes, diagAdden
         }
         else {
             const keyValue = keyType.literalValue;
-            const symbolEntry = symbolMap.get(keyValue);
+            const symbolEntry = tdEntries.knownItems.get(keyValue);
             if (!symbolEntry) {
-                // The provided key name doesn't exist.
-                isMatch = false;
-                if (diagAddendum) {
+                if (tdEntries.extraItems) {
                     const subDiag = diagAddendum === null || diagAddendum === void 0 ? void 0 : diagAddendum.createAddendum();
-                    subDiag.addMessage(localize_1.LocAddendum.typedDictFieldUndefined().format({
-                        name: keyType.literalValue,
-                        type: evaluator.printType(types_1.ClassType.cloneAsInstance(classType)),
-                    }));
-                    subDiag.addTextRange(keyTypeResult.node);
+                    if (!evaluator.assignType(tdEntries.extraItems.valueType, valueTypes[index].type, subDiag === null || subDiag === void 0 ? void 0 : subDiag.createAddendum(), typeVarContext, 
+                    /* srcTypeVarContext */ undefined, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */)) {
+                        if (subDiag) {
+                            subDiag.addMessage(localize_1.LocAddendum.typedDictFieldTypeMismatch().format({
+                                name: '__extra_items__',
+                                type: evaluator.printType(valueTypes[index].type),
+                            }));
+                            subDiag.addTextRange(keyTypeResult.node);
+                        }
+                        isMatch = false;
+                    }
+                }
+                else {
+                    // The provided key name doesn't exist.
+                    isMatch = false;
+                    if (diagAddendum) {
+                        const subDiag = diagAddendum === null || diagAddendum === void 0 ? void 0 : diagAddendum.createAddendum();
+                        subDiag.addMessage(localize_1.LocAddendum.typedDictFieldUndefined().format({
+                            name: keyType.literalValue,
+                            type: evaluator.printType(types_1.ClassType.cloneAsInstance(classType)),
+                        }));
+                        subDiag.addTextRange(keyTypeResult.node);
+                    }
                 }
             }
             else {
@@ -762,7 +977,7 @@ function assignToTypedDict(evaluator, classType, keyTypes, valueTypes, diagAdden
         return undefined;
     }
     // See if any required keys are missing.
-    symbolMap.forEach((entry, name) => {
+    tdEntries.knownItems.forEach((entry, name) => {
         if (entry.isRequired && !entry.isProvided) {
             if (diagAddendum) {
                 diagAddendum.addMessage(localize_1.LocAddendum.typedDictFieldRequired().format({
@@ -799,7 +1014,7 @@ function getTypeOfIndexedTypedDict(evaluator, node, baseType, usage) {
     let diag = new diagnostic_1.DiagnosticAddendum();
     let allDiagsInvolveNotRequiredKeys = true;
     const resultingType = (0, typeUtils_1.mapSubtypes)(indexType, (subtype) => {
-        var _a, _b;
+        var _a, _b, _c;
         if ((0, types_1.isAnyOrUnknown)(subtype)) {
             return subtype;
         }
@@ -811,7 +1026,7 @@ function getTypeOfIndexedTypedDict(evaluator, node, baseType, usage) {
             }
             // Look up the entry in the typed dict to get its type.
             const entryName = subtype.literalValue;
-            const entry = entries.get(entryName);
+            const entry = (_a = entries.knownItems.get(entryName)) !== null && _a !== void 0 ? _a : entries.extraItems;
             if (!entry) {
                 diag.addMessage(localize_1.LocAddendum.keyUndefined().format({
                     name: entryName,
@@ -835,7 +1050,7 @@ function getTypeOfIndexedTypedDict(evaluator, node, baseType, usage) {
                 }));
             }
             if (usage.method === 'set') {
-                if (!evaluator.assignType(entry.valueType, (_b = (_a = usage.setType) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.AnyType.create(), diag)) {
+                if (!evaluator.assignType(entry.valueType, (_c = (_b = usage.setType) === null || _b === void 0 ? void 0 : _b.type) !== null && _c !== void 0 ? _c : types_1.AnyType.create(), diag)) {
                     allDiagsInvolveNotRequiredKeys = false;
                 }
             }
@@ -885,7 +1100,7 @@ function narrowForKeyAssignment(classType, key) {
     if (!types_1.ClassType.isTypedDictClass(classType) || !classType.details.typedDictEntries) {
         return classType;
     }
-    const tdEntry = classType.details.typedDictEntries.get(key);
+    const tdEntry = classType.details.typedDictEntries.knownItems.get(key);
     if (!tdEntry || tdEntry.isRequired) {
         return classType;
     }
@@ -905,7 +1120,7 @@ function narrowForKeyAssignment(classType, key) {
     return types_1.ClassType.cloneForNarrowedTypedDictEntries(classType, narrowedEntries);
 }
 exports.narrowForKeyAssignment = narrowForKeyAssignment;
-function isRequiredTypedDictVariable(evaluator, symbol) {
+function isRequiredTypedDictVariable(evaluator, symbol, allowRequired) {
     return symbol.getDeclarations().some((decl) => {
         if (decl.type !== 1 /* DeclarationType.Variable */ || !decl.typeAnnotationNode) {
             return false;
@@ -914,10 +1129,16 @@ function isRequiredTypedDictVariable(evaluator, symbol) {
             allowFinal: true,
             allowRequired: true,
         });
+        if (!allowRequired) {
+            if (annotatedType.isRequired) {
+                evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.requiredNotInTypedDict(), decl.typeAnnotationNode);
+            }
+            return false;
+        }
         return !!annotatedType.isRequired;
     });
 }
-function isNotRequiredTypedDictVariable(evaluator, symbol) {
+function isNotRequiredTypedDictVariable(evaluator, symbol, allowRequired) {
     return symbol.getDeclarations().some((decl) => {
         if (decl.type !== 1 /* DeclarationType.Variable */ || !decl.typeAnnotationNode) {
             return false;
@@ -926,6 +1147,12 @@ function isNotRequiredTypedDictVariable(evaluator, symbol) {
             allowFinal: true,
             allowRequired: true,
         });
+        if (!allowRequired) {
+            if (annotatedType.isNotRequired) {
+                evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.notRequiredNotInTypedDict(), decl.typeAnnotationNode);
+            }
+            return false;
+        }
         return !!annotatedType.isNotRequired;
     });
 }