@zzzen/pyright-internal 1.1.254

package/dist/analyzer/typedDicts.js

@@ -0,0 +1,695 @@
+"use strict";
+/*
+ * typedDicts.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * Provides special-case logic for the construction of TypedDict
+ * classes.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypeOfIndexedTypedDict = exports.assignToTypedDict = exports.assignTypedDictToTypedDict = exports.getTypedDictMembersForClass = exports.synthesizeTypedDictClassMethods = exports.createTypedDictType = void 0;
+const collectionUtils_1 = require("../common/collectionUtils");
+const debug_1 = require("../common/debug");
+const diagnostic_1 = require("../common/diagnostic");
+const diagnosticRules_1 = require("../common/diagnosticRules");
+const positionUtils_1 = require("../common/positionUtils");
+const textRange_1 = require("../common/textRange");
+const localize_1 = require("../localization/localize");
+const AnalyzerNodeInfo = __importStar(require("./analyzerNodeInfo"));
+const ParseTreeUtils = __importStar(require("./parseTreeUtils"));
+const symbol_1 = require("./symbol");
+const symbolUtils_1 = require("./symbolUtils");
+const types_1 = require("./types");
+const typeUtils_1 = require("./typeUtils");
+const typeVarContext_1 = require("./typeVarContext");
+// Creates a new custom TypedDict factory class.
+function createTypedDictType(evaluator, errorNode, typedDictClass, argList) {
+    const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
+    // TypedDict supports two different syntaxes:
+    // Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': str})
+    // Point2D = TypedDict('Point2D', x=int, y=int, label=str)
+    let className = 'TypedDict';
+    if (argList.length === 0) {
+        evaluator.addError(localize_1.Localizer.Diagnostic.typedDictFirstArg(), errorNode);
+    }
+    else {
+        const nameArg = argList[0];
+        if (nameArg.argumentCategory !== 0 /* Simple */ ||
+            !nameArg.valueExpression ||
+            nameArg.valueExpression.nodeType !== 48 /* StringList */) {
+            evaluator.addError(localize_1.Localizer.Diagnostic.typedDictFirstArg(), argList[0].valueExpression || errorNode);
+        }
+        else {
+            className = nameArg.valueExpression.strings.map((s) => s.value).join('');
+        }
+    }
+    const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, 128 /* TypedDictClass */, ParseTreeUtils.getTypeSourceId(errorNode), 
+    /* declaredMetaclass */ undefined, typedDictClass.details.effectiveMetaclass);
+    classType.details.baseClasses.push(typedDictClass);
+    (0, typeUtils_1.computeMroLinearization)(classType);
+    const classFields = classType.details.fields;
+    classFields.set('__class__', symbol_1.Symbol.createWithType(4 /* ClassMember */ | 64 /* IgnoredForProtocolMatch */, classType));
+    let usingDictSyntax = false;
+    if (argList.length < 2) {
+        evaluator.addError(localize_1.Localizer.Diagnostic.typedDictSecondArgDict(), errorNode);
+    }
+    else {
+        const entriesArg = argList[1];
+        const entryMap = new Map();
+        if (entriesArg.argumentCategory === 0 /* Simple */ &&
+            entriesArg.valueExpression &&
+            entriesArg.valueExpression.nodeType === 15 /* Dictionary */) {
+            usingDictSyntax = true;
+            const entryDict = entriesArg.valueExpression;
+            entryDict.entries.forEach((entry) => {
+                if (entry.nodeType !== 17 /* DictionaryKeyEntry */) {
+                    evaluator.addError(localize_1.Localizer.Diagnostic.typedDictSecondArgDictEntry(), entry);
+                    return;
+                }
+                if (entry.keyExpression.nodeType !== 48 /* StringList */) {
+                    evaluator.addError(localize_1.Localizer.Diagnostic.typedDictEntryName(), entry.keyExpression);
+                    return;
+                }
+                const entryName = entry.keyExpression.strings.map((s) => s.value).join('');
+                if (!entryName) {
+                    evaluator.addError(localize_1.Localizer.Diagnostic.typedDictEmptyName(), entry.keyExpression);
+                    return;
+                }
+                if (entryMap.has(entryName)) {
+                    evaluator.addError(localize_1.Localizer.Diagnostic.typedDictEntryUnique(), entry.keyExpression);
+                    return;
+                }
+                // Record names in a map to detect duplicates.
+                entryMap.set(entryName, true);
+                // Cache the annotation type.
+                const annotatedType = evaluator.getTypeOfExpressionExpectingType(entry.valueExpression, 
+                /* allowFinal */ true, 
+                /* allowRequired */ true);
+                const newSymbol = new symbol_1.Symbol(8 /* InstanceMember */);
+                const declaration = {
+                    type: 1 /* Variable */,
+                    node: entry.keyExpression,
+                    path: fileInfo.filePath,
+                    typeAnnotationNode: entry.valueExpression,
+                    isRequired: annotatedType.isRequired,
+                    isNotRequired: annotatedType.isNotRequired,
+                    isRuntimeTypeExpression: true,
+                    range: (0, positionUtils_1.convertOffsetsToRange)(entry.keyExpression.start, textRange_1.TextRange.getEnd(entry.keyExpression), fileInfo.lines),
+                    moduleName: fileInfo.moduleName,
+                    isInExceptSuite: false,
+                };
+                newSymbol.addDeclaration(declaration);
+                classFields.set(entryName, newSymbol);
+            });
+            // Set the type in the type cache for the dict node so it doesn't
+            // get evaluated again.
+            evaluator.setTypeForNode(entryDict);
+        }
+        else if (entriesArg.name) {
+            for (let i = 1; i < argList.length; i++) {
+                const entry = argList[i];
+                if (!entry.name || !entry.valueExpression) {
+                    continue;
+                }
+                if (entryMap.has(entry.name.value)) {
+                    evaluator.addError(localize_1.Localizer.Diagnostic.typedDictEntryUnique(), entry.valueExpression);
+                    continue;
+                }
+                // Record names in a map to detect duplicates.
+                entryMap.set(entry.name.value, true);
+                // Evaluate the type with specific evaluation flags. The
+                // type will be cached for later.
+                const annotatedType = evaluator.getTypeOfExpressionExpectingType(entry.valueExpression, 
+                /* allowFinal */ true, 
+                /* allowRequired */ true);
+                const newSymbol = new symbol_1.Symbol(8 /* InstanceMember */);
+                const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
+                const declaration = {
+                    type: 1 /* Variable */,
+                    node: entry.name,
+                    path: fileInfo.filePath,
+                    typeAnnotationNode: entry.valueExpression,
+                    isRequired: annotatedType.isRequired,
+                    isNotRequired: annotatedType.isNotRequired,
+                    isRuntimeTypeExpression: true,
+                    range: (0, positionUtils_1.convertOffsetsToRange)(entry.name.start, textRange_1.TextRange.getEnd(entry.valueExpression), fileInfo.lines),
+                    moduleName: fileInfo.moduleName,
+                    isInExceptSuite: false,
+                };
+                newSymbol.addDeclaration(declaration);
+                classFields.set(entry.name.value, newSymbol);
+            }
+        }
+        else {
+            evaluator.addError(localize_1.Localizer.Diagnostic.typedDictSecondArgDict(), errorNode);
+        }
+    }
+    if (usingDictSyntax) {
+        if (argList.length >= 3) {
+            if (!argList[2].name ||
+                argList[2].name.value !== 'total' ||
+                !argList[2].valueExpression ||
+                argList[2].valueExpression.nodeType !== 11 /* Constant */ ||
+                !(argList[2].valueExpression.constType === 15 /* False */ ||
+                    argList[2].valueExpression.constType === 33 /* True */)) {
+                evaluator.addError(localize_1.Localizer.Diagnostic.typedDictTotalParam(), argList[2].valueExpression || errorNode);
+            }
+            else if (argList[2].valueExpression.constType === 15 /* False */) {
+                classType.details.flags |= 256 /* CanOmitDictValues */;
+            }
+        }
+        if (argList.length > 3) {
+            evaluator.addError(localize_1.Localizer.Diagnostic.typedDictExtraArgs(), argList[3].valueExpression || errorNode);
+        }
+    }
+    synthesizeTypedDictClassMethods(evaluator, errorNode, classType, /* isClassFinal */ false);
+    return classType;
+}
+exports.createTypedDictType = createTypedDictType;
+function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFinal) {
+    (0, debug_1.assert)(types_1.ClassType.isTypedDictClass(classType));
+    // Synthesize a __new__ method.
+    const newType = types_1.FunctionType.createSynthesizedInstance('__new__', 1 /* ConstructorMethod */);
+    types_1.FunctionType.addParameter(newType, {
+        category: 0 /* Simple */,
+        name: 'cls',
+        type: classType,
+        hasDeclaredType: true,
+    });
+    types_1.FunctionType.addDefaultParameters(newType);
+    newType.details.declaredReturnType = types_1.ClassType.cloneAsInstance(classType);
+    // Synthesize an __init__ method.
+    const initType = types_1.FunctionType.createSynthesizedInstance('__init__');
+    types_1.FunctionType.addParameter(initType, {
+        category: 0 /* Simple */,
+        name: 'self',
+        type: types_1.ClassType.cloneAsInstance(classType),
+        hasDeclaredType: true,
+    });
+    initType.details.declaredReturnType = types_1.NoneType.createInstance();
+    // All parameters must be named, so insert an empty "*".
+    types_1.FunctionType.addParameter(initType, {
+        category: 1 /* VarArgList */,
+        type: types_1.AnyType.create(),
+        hasDeclaredType: true,
+    });
+    const entries = getTypedDictMembersForClass(evaluator, classType);
+    entries.forEach((entry, name) => {
+        types_1.FunctionType.addParameter(initType, {
+            category: 0 /* Simple */,
+            name,
+            hasDefault: !entry.isRequired,
+            type: entry.valueType,
+            hasDeclaredType: true,
+        });
+    });
+    const symbolTable = classType.details.fields;
+    symbolTable.set('__init__', symbol_1.Symbol.createWithType(4 /* ClassMember */, initType));
+    symbolTable.set('__new__', symbol_1.Symbol.createWithType(4 /* ClassMember */, newType));
+    const strClass = evaluator.getBuiltInType(node, 'str');
+    // Synthesize a "get", pop, and setdefault method for each named entry.
+    if ((0, types_1.isInstantiableClass)(strClass)) {
+        const selfParam = {
+            category: 0 /* Simple */,
+            name: 'self',
+            type: types_1.ClassType.cloneAsInstance(classType),
+            hasDeclaredType: true,
+        };
+        const createDefaultTypeVar = (func) => {
+            let defaultTypeVar = types_1.TypeVarType.createInstance(`__TDefault`);
+            defaultTypeVar = types_1.TypeVarType.cloneForScopeId(defaultTypeVar, func.details.typeVarScopeId, classType.details.name, 1 /* Function */);
+            return defaultTypeVar;
+        };
+        const createGetMethod = (keyType, valueType, includeDefault, isEntryRequired = false, defaultTypeMatchesField = false) => {
+            const getOverload = types_1.FunctionType.createSynthesizedInstance('get', 256 /* Overloaded */);
+            types_1.FunctionType.addParameter(getOverload, selfParam);
+            getOverload.details.typeVarScopeId = evaluator.getScopeIdForNode(node);
+            types_1.FunctionType.addParameter(getOverload, {
+                category: 0 /* Simple */,
+                name: 'k',
+                type: keyType,
+                hasDeclaredType: true,
+            });
+            if (includeDefault) {
+                const defaultTypeVar = createDefaultTypeVar(getOverload);
+                let defaultParamType;
+                let returnType;
+                if (isEntryRequired) {
+                    // If the entry is required, the type of the default param doesn't matter
+                    // because the type will always come from the value.
+                    defaultParamType = types_1.AnyType.create();
+                    returnType = valueType !== null && valueType !== void 0 ? valueType : types_1.AnyType.create();
+                }
+                else {
+                    defaultParamType = defaultTypeMatchesField && valueType ? valueType : defaultTypeVar;
+                    if (valueType) {
+                        returnType = defaultTypeMatchesField ? valueType : (0, types_1.combineTypes)([valueType, defaultTypeVar]);
+                    }
+                    else {
+                        returnType = defaultTypeVar;
+                    }
+                }
+                types_1.FunctionType.addParameter(getOverload, {
+                    category: 0 /* Simple */,
+                    name: 'default',
+                    type: defaultParamType,
+                    hasDeclaredType: true,
+                });
+                getOverload.details.declaredReturnType = returnType;
+            }
+            else {
+                getOverload.details.declaredReturnType = isEntryRequired
+                    ? valueType
+                    : (0, types_1.combineTypes)([valueType !== null && valueType !== void 0 ? valueType : types_1.AnyType.create(), types_1.NoneType.createInstance()]);
+            }
+            return getOverload;
+        };
+        const createPopMethods = (keyType, valueType) => {
+            const keyParam = {
+                category: 0 /* Simple */,
+                name: 'k',
+                type: keyType,
+                hasDeclaredType: true,
+            };
+            const popOverload1 = types_1.FunctionType.createSynthesizedInstance('pop', 256 /* Overloaded */);
+            types_1.FunctionType.addParameter(popOverload1, selfParam);
+            types_1.FunctionType.addParameter(popOverload1, keyParam);
+            popOverload1.details.declaredReturnType = valueType;
+            const popOverload2 = types_1.FunctionType.createSynthesizedInstance('pop', 256 /* Overloaded */);
+            types_1.FunctionType.addParameter(popOverload2, selfParam);
+            types_1.FunctionType.addParameter(popOverload2, keyParam);
+            popOverload2.details.typeVarScopeId = evaluator.getScopeIdForNode(node);
+            const defaultTypeVar = createDefaultTypeVar(popOverload2);
+            types_1.FunctionType.addParameter(popOverload2, {
+                category: 0 /* Simple */,
+                name: 'default',
+                hasDeclaredType: true,
+                type: defaultTypeVar,
+                hasDefault: true,
+            });
+            popOverload2.details.declaredReturnType = (0, types_1.combineTypes)([valueType, defaultTypeVar]);
+            return [popOverload1, popOverload2];
+        };
+        const createSetDefaultMethod = (keyType, valueType) => {
+            const setDefaultOverload = types_1.FunctionType.createSynthesizedInstance('setdefault', 256 /* Overloaded */);
+            types_1.FunctionType.addParameter(setDefaultOverload, selfParam);
+            types_1.FunctionType.addParameter(setDefaultOverload, {
+                category: 0 /* Simple */,
+                name: 'k',
+                hasDeclaredType: true,
+                type: keyType,
+            });
+            types_1.FunctionType.addParameter(setDefaultOverload, {
+                category: 0 /* Simple */,
+                name: 'default',
+                hasDeclaredType: true,
+                type: valueType,
+            });
+            setDefaultOverload.details.declaredReturnType = valueType;
+            return setDefaultOverload;
+        };
+        const createDelItemMethod = (keyType) => {
+            const delItemOverload = types_1.FunctionType.createSynthesizedInstance('delitem', 256 /* Overloaded */);
+            types_1.FunctionType.addParameter(delItemOverload, selfParam);
+            types_1.FunctionType.addParameter(delItemOverload, {
+                category: 0 /* Simple */,
+                name: 'k',
+                hasDeclaredType: true,
+                type: keyType,
+            });
+            delItemOverload.details.declaredReturnType = types_1.NoneType.createInstance();
+            return delItemOverload;
+        };
+        const getOverloads = [];
+        const popOverloads = [];
+        const setDefaultOverloads = [];
+        entries.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));
+            if (entry.isRequired) {
+                getOverloads.push(createGetMethod(nameLiteralType, entry.valueType, 
+                /* includeDefault */ true, 
+                /* isEntryRequired */ true, 
+                /* defaultTypeMatchesField */ true));
+            }
+            else {
+                getOverloads.push(createGetMethod(nameLiteralType, entry.valueType, 
+                /* includeDefault */ true, 
+                /* isEntryRequired */ false, 
+                /* defaultTypeMatchesField */ true));
+                getOverloads.push(createGetMethod(nameLiteralType, entry.valueType, 
+                /* includeDefault */ true, 
+                /* isEntryRequired */ false, 
+                /* defaultTypeMatchesField */ false));
+            }
+            // Add a pop method if the entry is not required.
+            if (!entry.isRequired) {
+                (0, collectionUtils_1.appendArray)(popOverloads, createPopMethods(nameLiteralType, entry.valueType));
+            }
+            setDefaultOverloads.push(createSetDefaultMethod(nameLiteralType, entry.valueType));
+        });
+        // If the class is marked "@final", we can assume that any other literal
+        // key values will return the default parameter value.
+        if (isClassFinal) {
+            const literalStringType = evaluator.getTypingType(node, 'LiteralString');
+            if (literalStringType && (0, types_1.isInstantiableClass)(literalStringType)) {
+                const literalStringInstance = types_1.ClassType.cloneAsInstance(literalStringType);
+                getOverloads.push(createGetMethod(literalStringInstance, types_1.NoneType.createInstance(), 
+                /* includeDefault */ false, 
+                /* isEntryRequired */ true));
+                getOverloads.push(createGetMethod(literalStringInstance, /* valueType */ undefined, /* includeDefault */ true));
+            }
+        }
+        // Provide a final `get` overload that handles the general case where
+        // the key is a str but the literal value isn't known.
+        const strType = types_1.ClassType.cloneAsInstance(strClass);
+        getOverloads.push(createGetMethod(strType, types_1.AnyType.create(), /* includeDefault */ false));
+        getOverloads.push(createGetMethod(strType, types_1.AnyType.create(), /* includeDefault */ true));
+        symbolTable.set('get', symbol_1.Symbol.createWithType(4 /* ClassMember */, types_1.OverloadedFunctionType.create(getOverloads)));
+        if (popOverloads.length > 0) {
+            symbolTable.set('pop', symbol_1.Symbol.createWithType(4 /* ClassMember */, types_1.OverloadedFunctionType.create(popOverloads)));
+        }
+        if (setDefaultOverloads.length > 0) {
+            symbolTable.set('setdefault', symbol_1.Symbol.createWithType(4 /* ClassMember */, types_1.OverloadedFunctionType.create(setDefaultOverloads)));
+        }
+        symbolTable.set('__delitem__', symbol_1.Symbol.createWithType(4 /* ClassMember */, createDelItemMethod(strType)));
+    }
+}
+exports.synthesizeTypedDictClassMethods = synthesizeTypedDictClassMethods;
+function getTypedDictMembersForClass(evaluator, classType, allowNarrowed = false) {
+    // Were the entries already calculated and cached?
+    if (!classType.details.typedDictEntries) {
+        const entries = new Map();
+        getTypedDictMembersForClassRecursive(evaluator, classType, entries);
+        // 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) => {
+        const tdEntry = { ...value };
+        tdEntry.valueType = (0, typeUtils_1.applySolvedTypeVars)(tdEntry.valueType, typeVarContext);
+        entries.set(key, tdEntry);
+    });
+    // Apply narrowed types on top of existing entries if present.
+    if (allowNarrowed && classType.typedDictNarrowedEntries) {
+        classType.typedDictNarrowedEntries.forEach((value, key) => {
+            const tdEntry = { ...value };
+            tdEntry.valueType = (0, typeUtils_1.applySolvedTypeVars)(tdEntry.valueType, typeVarContext);
+            entries.set(key, tdEntry);
+        });
+    }
+    return entries;
+}
+exports.getTypedDictMembersForClass = getTypedDictMembersForClass;
+function getTypedDictMembersForClassRecursive(evaluator, classType, keyMap, recursionCount = 0) {
+    (0, debug_1.assert)(types_1.ClassType.isTypedDictClass(classType));
+    if (recursionCount > types_1.maxTypeRecursionCount) {
+        return;
+    }
+    recursionCount++;
+    classType.details.baseClasses.forEach((baseClassType) => {
+        if ((0, types_1.isInstantiableClass)(baseClassType) && types_1.ClassType.isTypedDictClass(baseClassType)) {
+            getTypedDictMembersForClassRecursive(evaluator, baseClassType, keyMap, recursionCount);
+        }
+    });
+    const typeVarContext = (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(classType);
+    // Add any new typed dict entries from this class.
+    classType.details.fields.forEach((symbol, name) => {
+        if (!symbol.isIgnoredForProtocolMatch()) {
+            // Only variables (not functions, classes, etc.) are considered.
+            const lastDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
+            if (lastDecl && lastDecl.type === 1 /* Variable */) {
+                let valueType = evaluator.getEffectiveTypeOfSymbol(symbol);
+                valueType = (0, typeUtils_1.applySolvedTypeVars)(valueType, typeVarContext);
+                let isRequired = !types_1.ClassType.isCanOmitDictValues(classType);
+                if ((0, symbolUtils_1.isRequiredTypedDictVariable)(symbol)) {
+                    isRequired = true;
+                }
+                else if ((0, symbolUtils_1.isNotRequiredTypedDictVariable)(symbol)) {
+                    isRequired = false;
+                }
+                // If a base class already declares this field, verify that the
+                // subclass isn't trying to change its type. That's expressly
+                // forbidden in PEP 589.
+                const existingEntry = keyMap.get(name);
+                if (existingEntry) {
+                    if (!(0, types_1.isTypeSame)(existingEntry.valueType, valueType)) {
+                        const diag = new diagnostic_1.DiagnosticAddendum();
+                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typedDictFieldRedefinition().format({
+                            parentType: evaluator.printType(existingEntry.valueType),
+                            childType: evaluator.printType(valueType),
+                        }));
+                        evaluator.addDiagnostic(AnalyzerNodeInfo.getFileInfo(lastDecl.node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typedDictFieldRedefinition().format({
+                            name,
+                        }) + diag.getString(), lastDecl.node);
+                    }
+                }
+                keyMap.set(name, {
+                    valueType,
+                    isRequired,
+                    isProvided: false,
+                });
+            }
+        }
+    });
+}
+function assignTypedDictToTypedDict(evaluator, destType, srcType, diag, typeVarContext, flags, recursionCount = 0) {
+    let typesAreConsistent = true;
+    const destEntries = getTypedDictMembersForClass(evaluator, destType);
+    const srcEntries = getTypedDictMembersForClass(evaluator, srcType, /* allowNarrowed */ true);
+    destEntries.forEach((destEntry, name) => {
+        const srcEntry = srcEntries.get(name);
+        if (!srcEntry) {
+            diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.Localizer.DiagnosticAddendum.typedDictFieldMissing().format({
+                name,
+                type: evaluator.printType(srcType),
+            }));
+            typesAreConsistent = false;
+        }
+        else {
+            if (destEntry.isRequired && !srcEntry.isRequired) {
+                diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.Localizer.DiagnosticAddendum.typedDictFieldRequired().format({
+                    name,
+                    type: evaluator.printType(destType),
+                }));
+                typesAreConsistent = false;
+            }
+            else if (!destEntry.isRequired && srcEntry.isRequired) {
+                diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.Localizer.DiagnosticAddendum.typedDictFieldNotRequired().format({
+                    name,
+                    type: evaluator.printType(destType),
+                }));
+                typesAreConsistent = false;
+            }
+            const subDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
+            if (!evaluator.assignType(destEntry.valueType, srcEntry.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.Localizer.DiagnosticAddendum.memberTypeMismatch().format({ name }));
+                typesAreConsistent = false;
+            }
+        }
+    });
+    return typesAreConsistent;
+}
+exports.assignTypedDictToTypedDict = assignTypedDictToTypedDict;
+// Determines whether the specified keys and values can be assigned to
+// a typed dictionary class. The caller should have already validated
+// that the class is indeed a typed dict. If the types are compatible,
+// the typed dict class or a narrowed form of the class is returned.
+// Narrowing is possible when not-required keys are provided. If the
+// types are not compatible, the function returns undefined.
+function assignToTypedDict(evaluator, classType, keyTypes, valueTypes, diagAddendum) {
+    (0, debug_1.assert)((0, types_1.isClassInstance)(classType));
+    (0, debug_1.assert)(types_1.ClassType.isTypedDictClass(classType));
+    (0, debug_1.assert)(keyTypes.length === valueTypes.length);
+    let isMatch = true;
+    const narrowedEntries = new Map();
+    let typeVarContext;
+    let genericClassType = classType;
+    if (classType.details.typeParameters.length > 0) {
+        typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(classType));
+        // Create a generic (nonspecialized version) of the class.
+        if (classType.typeArguments) {
+            genericClassType = types_1.ClassType.cloneForSpecialization(classType, 
+            /* typeArguments */ undefined, 
+            /* isTypeArgumentExplicit */ false);
+        }
+    }
+    const symbolMap = getTypedDictMembersForClass(evaluator, genericClassType);
+    keyTypes.forEach((keyType, index) => {
+        if (!(0, types_1.isClassInstance)(keyType) || !types_1.ClassType.isBuiltIn(keyType, 'str') || !(0, typeUtils_1.isLiteralType)(keyType)) {
+            isMatch = false;
+        }
+        else {
+            const keyValue = keyType.literalValue;
+            const symbolEntry = symbolMap.get(keyValue);
+            if (!symbolEntry) {
+                // The provided key name doesn't exist.
+                isMatch = false;
+                if (diagAddendum) {
+                    diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.typedDictFieldUndefined().format({
+                        name: keyType.literalValue,
+                        type: evaluator.printType(types_1.ClassType.cloneAsInstance(classType)),
+                    }));
+                }
+            }
+            else {
+                // Can we assign the value to the declared type?
+                const subDiag = diagAddendum === null || diagAddendum === void 0 ? void 0 : diagAddendum.createAddendum();
+                if (!evaluator.assignType(symbolEntry.valueType, valueTypes[index], subDiag === null || subDiag === void 0 ? void 0 : subDiag.createAddendum(), typeVarContext)) {
+                    if (subDiag) {
+                        subDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.typedDictFieldTypeMismatch().format({
+                            name: keyType.literalValue,
+                            type: evaluator.printType(valueTypes[index]),
+                        }));
+                    }
+                    isMatch = false;
+                }
+                if (!symbolEntry.isRequired) {
+                    narrowedEntries.set(keyValue, {
+                        valueType: valueTypes[index],
+                        isRequired: false,
+                        isProvided: true,
+                    });
+                }
+                symbolEntry.isProvided = true;
+            }
+        }
+    });
+    if (!isMatch) {
+        return undefined;
+    }
+    // See if any required keys are missing.
+    symbolMap.forEach((entry, name) => {
+        if (entry.isRequired && !entry.isProvided) {
+            if (diagAddendum) {
+                diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.typedDictFieldRequired().format({
+                    name,
+                    type: evaluator.printType(classType),
+                }));
+            }
+            isMatch = false;
+        }
+    });
+    if (!isMatch) {
+        return undefined;
+    }
+    const specializedClassType = typeVarContext
+        ? (0, typeUtils_1.applySolvedTypeVars)(genericClassType, typeVarContext)
+        : classType;
+    return narrowedEntries.size === 0
+        ? specializedClassType
+        : types_1.ClassType.cloneForNarrowedTypedDictEntries(specializedClassType, narrowedEntries);
+}
+exports.assignToTypedDict = assignToTypedDict;
+function getTypeOfIndexedTypedDict(evaluator, node, baseType, usage) {
+    if (node.items.length !== 1) {
+        evaluator.addError(localize_1.Localizer.Diagnostic.typeArgsMismatchOne().format({ received: node.items.length }), node);
+        return { node, type: types_1.UnknownType.create() };
+    }
+    // Look for subscript types that are not supported by TypedDict.
+    if (node.trailingComma || node.items[0].name || node.items[0].argumentCategory !== 0 /* Simple */) {
+        return undefined;
+    }
+    const entries = getTypedDictMembersForClass(evaluator, baseType, /* allowNarrowed */ usage.method === 'get');
+    const indexTypeResult = evaluator.getTypeOfExpression(node.items[0].valueExpression);
+    const indexType = indexTypeResult.type;
+    let diag = new diagnostic_1.DiagnosticAddendum();
+    let allDiagsInvolveNotRequiredKeys = true;
+    const resultingType = (0, typeUtils_1.mapSubtypes)(indexType, (subtype) => {
+        if ((0, types_1.isAnyOrUnknown)(subtype)) {
+            return subtype;
+        }
+        if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'str')) {
+            if (subtype.literalValue === undefined) {
+                // If it's a plain str with no literal value, we can't
+                // make any determination about the resulting type.
+                return types_1.UnknownType.create();
+            }
+            // Look up the entry in the typed dict to get its type.
+            const entryName = subtype.literalValue;
+            const entry = entries.get(entryName);
+            if (!entry) {
+                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.keyUndefined().format({
+                    name: entryName,
+                    type: evaluator.printType(baseType),
+                }));
+                allDiagsInvolveNotRequiredKeys = false;
+                return types_1.UnknownType.create();
+            }
+            else if (!(entry.isRequired || entry.isProvided) && usage.method === 'get') {
+                if (!ParseTreeUtils.isWithinTryBlock(node, /* treatWithAsTryBlock */ true)) {
+                    diag.addMessage(localize_1.Localizer.DiagnosticAddendum.keyNotRequired().format({
+                        name: entryName,
+                        type: evaluator.printType(baseType),
+                    }));
+                }
+            }
+            if (usage.method === 'set') {
+                if (!evaluator.assignType(entry.valueType, usage.setType || types_1.AnyType.create(), diag)) {
+                    allDiagsInvolveNotRequiredKeys = false;
+                }
+            }
+            else if (usage.method === 'del' && entry.isRequired) {
+                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.keyRequiredDeleted().format({
+                    name: entryName,
+                }));
+                allDiagsInvolveNotRequiredKeys = false;
+            }
+            return entry.valueType;
+        }
+        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeNotStringLiteral().format({ type: evaluator.printType(subtype) }));
+        allDiagsInvolveNotRequiredKeys = false;
+        return types_1.UnknownType.create();
+    });
+    // If we have an "expected type" diagnostic addendum (used for assignments),
+    // use that rather than the local diagnostic information because it will
+    // be more informative.
+    if (usage.setExpectedTypeDiag && !diag.isEmpty() && !usage.setExpectedTypeDiag.isEmpty()) {
+        diag = usage.setExpectedTypeDiag;
+    }
+    if (!diag.isEmpty()) {
+        let typedDictDiag;
+        if (usage.method === 'set') {
+            typedDictDiag = localize_1.Localizer.Diagnostic.typedDictSet();
+        }
+        else if (usage.method === 'del') {
+            typedDictDiag = localize_1.Localizer.Diagnostic.typedDictDelete();
+        }
+        else {
+            typedDictDiag = localize_1.Localizer.Diagnostic.typedDictAccess();
+        }
+        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+        evaluator.addDiagnostic(allDiagsInvolveNotRequiredKeys
+            ? fileInfo.diagnosticRuleSet.reportTypedDictNotRequiredAccess
+            : fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, allDiagsInvolveNotRequiredKeys
+            ? diagnosticRules_1.DiagnosticRule.reportTypedDictNotRequiredAccess
+            : diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, typedDictDiag + diag.getString(), node);
+    }
+    return { node, type: resultingType, isIncomplete: !!indexTypeResult.isIncomplete };
+}
+exports.getTypeOfIndexedTypedDict = getTypeOfIndexedTypedDict;
+//# sourceMappingURL=typedDicts.js.map