@zzzen/pyright-internal 1.2.0-dev.20240707 → 1.2.0-dev.20240721

package/dist/analyzer/typedDicts.js

@@ -66,13 +66,13 @@ function createTypedDictType(evaluator, errorNode, typedDictClass, argList) {
             evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportArgumentType, localize_1.LocMessage.typedDictFirstArg(), argList[0].valueExpression || errorNode);
         }
         else {
-            className = nameArg.valueExpression.strings.map((s) => s.value).join('');
+            className = nameArg.valueExpression.d.strings.map((s) => s.d.value).join('');
         }
     }
     const effectiveClassName = className || 'TypedDict';
     const classType = types_1.ClassType.createInstantiable(effectiveClassName, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, effectiveClassName), fileInfo.moduleName, fileInfo.fileUri, 4 /* ClassTypeFlags.TypedDictClass */ | 4194304 /* ClassTypeFlags.ValidTypeAliasClass */, ParseTreeUtils.getTypeSourceId(errorNode), 
-    /* declaredMetaclass */ undefined, typedDictClass.details.effectiveMetaclass);
-    classType.details.baseClasses.push(typedDictClass);
+    /* declaredMetaclass */ undefined, typedDictClass.shared.effectiveMetaclass);
+    classType.shared.baseClasses.push(typedDictClass);
     (0, typeUtils_1.computeMroLinearization)(classType);
     const classFields = types_1.ClassType.getSymbolTable(classType);
     classFields.set('__class__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */ | 64 /* SymbolFlags.IgnoredForProtocolMatch */, classType));
@@ -95,12 +95,12 @@ function createTypedDictType(evaluator, errorNode, typedDictClass, argList) {
                 if (!entry.name || !entry.valueExpression) {
                     continue;
                 }
-                if (entrySet.has(entry.name.value)) {
+                if (entrySet.has(entry.name.d.value)) {
                     evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictEntryUnique(), entry.valueExpression);
                     continue;
                 }
                 // Record names in a map to detect duplicates.
-                entrySet.add(entry.name.value);
+                entrySet.add(entry.name.d.value);
                 const newSymbol = new symbol_1.Symbol(8 /* SymbolFlags.InstanceMember */);
                 const declaration = {
                     type: 1 /* DeclarationType.Variable */,
@@ -113,7 +113,7 @@ function createTypedDictType(evaluator, errorNode, typedDictClass, argList) {
                     isInExceptSuite: false,
                 };
                 newSymbol.addDeclaration(declaration);
-                classFields.set(entry.name.value, newSymbol);
+                classFields.set(entry.name.d.value, newSymbol);
             }
         }
         else {
@@ -122,20 +122,20 @@ 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' || ((_b = arg.name) === null || _b === void 0 ? void 0 : _b.value) === 'closed') {
+            if (((_a = arg.name) === null || _a === void 0 ? void 0 : _a.d.value) === 'total' || ((_b = arg.name) === null || _b === void 0 ? void 0 : _b.d.value) === 'closed') {
                 if (!arg.valueExpression ||
                     arg.valueExpression.nodeType !== 14 /* ParseNodeType.Constant */ ||
-                    !(arg.valueExpression.constType === 15 /* KeywordType.False */ ||
-                        arg.valueExpression.constType === 33 /* KeywordType.True */)) {
-                    evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictBoolParam().format({ name: arg.name.value }), arg.valueExpression || errorNode);
+                    !(arg.valueExpression.d.constType === 15 /* KeywordType.False */ ||
+                        arg.valueExpression.d.constType === 33 /* KeywordType.True */)) {
+                    evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictBoolParam().format({ name: arg.name.d.value }), arg.valueExpression || errorNode);
                 }
-                else if (arg.name.value === 'total' && arg.valueExpression.constType === 15 /* KeywordType.False */) {
-                    classType.details.flags |= 32 /* ClassTypeFlags.CanOmitDictValues */;
+                else if (arg.name.d.value === 'total' && arg.valueExpression.d.constType === 15 /* KeywordType.False */) {
+                    classType.shared.flags |= 32 /* ClassTypeFlags.CanOmitDictValues */;
                 }
-                else if (arg.name.value === 'closed' && arg.valueExpression.constType === 33 /* KeywordType.True */) {
+                else if (arg.name.d.value === 'closed' && arg.valueExpression.d.constType === 33 /* KeywordType.True */) {
                     // This is an experimental feature because PEP 728 hasn't been accepted yet.
                     if (AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.enableExperimentalFeatures) {
-                        classType.details.flags |=
+                        classType.shared.flags |=
                             8 /* ClassTypeFlags.TypedDictMarkedClosed */ | 16 /* ClassTypeFlags.TypedDictEffectivelyClosed */;
                     }
                 }
@@ -148,10 +148,10 @@ function createTypedDictType(evaluator, errorNode, typedDictClass, argList) {
     synthesizeTypedDictClassMethods(evaluator, errorNode, classType);
     // Validate that the assigned variable name is consistent with the provided name.
     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;
+        const target = errorNode.parent.d.leftExpr;
+        const typedDictTarget = target.nodeType === 54 /* ParseNodeType.TypeAnnotation */ ? target.d.valueExpr : target;
         if (typedDictTarget.nodeType === 38 /* ParseNodeType.Name */) {
-            if (typedDictTarget.value !== className) {
+            if (typedDictTarget.d.value !== className) {
                 evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictAssignedName().format({
                     name: className,
                 }), typedDictTarget);
@@ -166,83 +166,39 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType) {
     (0, debug_1.assert)(types_1.ClassType.isTypedDictClass(classType));
     // Synthesize a __new__ method.
     const newType = types_1.FunctionType.createSynthesizedInstance('__new__', 1 /* FunctionTypeFlags.ConstructorMethod */);
-    types_1.FunctionType.addParameter(newType, {
-        category: 0 /* ParameterCategory.Simple */,
-        name: 'cls',
-        type: classType,
-        hasDeclaredType: true,
-    });
+    types_1.FunctionType.addParameter(newType, types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, classType, types_1.FunctionParamFlags.TypeDeclared, 'cls'));
     types_1.FunctionType.addDefaultParameters(newType);
-    newType.details.declaredReturnType = types_1.ClassType.cloneAsInstance(classType);
-    newType.details.constructorTypeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(classType);
+    newType.shared.declaredReturnType = types_1.ClassType.cloneAsInstance(classType);
+    newType.priv.constructorTypeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(classType);
     // Synthesize an __init__ method with two overrides.
     const initOverride1 = types_1.FunctionType.createSynthesizedInstance('__init__', 256 /* FunctionTypeFlags.Overloaded */);
-    types_1.FunctionType.addParameter(initOverride1, {
-        category: 0 /* ParameterCategory.Simple */,
-        name: 'self',
-        type: types_1.ClassType.cloneAsInstance(classType),
-        hasDeclaredType: true,
-    });
-    initOverride1.details.declaredReturnType = evaluator.getNoneType();
-    initOverride1.details.constructorTypeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(classType);
+    types_1.FunctionType.addParameter(initOverride1, types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, types_1.ClassType.cloneAsInstance(classType), types_1.FunctionParamFlags.TypeDeclared, 'self'));
+    initOverride1.shared.declaredReturnType = evaluator.getNoneType();
+    initOverride1.priv.constructorTypeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(classType);
     // The first parameter must be positional-only.
-    types_1.FunctionType.addParameter(initOverride1, {
-        category: 0 /* ParameterCategory.Simple */,
-        name: '__map',
-        type: types_1.ClassType.cloneAsInstance(classType),
-        hasDeclaredType: true,
-    });
+    types_1.FunctionType.addParameter(initOverride1, types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, types_1.ClassType.cloneAsInstance(classType), types_1.FunctionParamFlags.TypeDeclared, '__map'));
     types_1.FunctionType.addPositionOnlyParameterSeparator(initOverride1);
     // All subsequent parameters must be named, so insert an empty "*".
     types_1.FunctionType.addKeywordOnlyParameterSeparator(initOverride1);
     const initOverride2 = types_1.FunctionType.createSynthesizedInstance('__init__', 256 /* FunctionTypeFlags.Overloaded */);
-    types_1.FunctionType.addParameter(initOverride2, {
-        category: 0 /* ParameterCategory.Simple */,
-        name: 'self',
-        type: types_1.ClassType.cloneAsInstance(classType),
-        hasDeclaredType: true,
-    });
-    initOverride2.details.declaredReturnType = evaluator.getNoneType();
-    initOverride2.details.constructorTypeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(classType);
+    types_1.FunctionType.addParameter(initOverride2, types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, types_1.ClassType.cloneAsInstance(classType), types_1.FunctionParamFlags.TypeDeclared, 'self'));
+    initOverride2.shared.declaredReturnType = evaluator.getNoneType();
+    initOverride2.priv.constructorTypeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(classType);
     // All parameters must be named, so insert an empty "*".
     types_1.FunctionType.addKeywordOnlyParameterSeparator(initOverride2);
     const entries = getTypedDictMembersForClass(evaluator, classType);
     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,
-            hasDefault: true,
-            type: entry.valueType,
-            hasDeclaredType: true,
-        });
-        types_1.FunctionType.addParameter(initOverride2, {
-            category: 0 /* ParameterCategory.Simple */,
-            name,
-            hasDefault: !entry.isRequired,
-            type: entry.valueType,
-            hasDeclaredType: true,
-        });
+        types_1.FunctionType.addParameter(initOverride1, types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, entry.valueType, types_1.FunctionParamFlags.TypeDeclared, name, entry.valueType));
+        types_1.FunctionType.addParameter(initOverride2, types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, entry.valueType, types_1.FunctionParamFlags.TypeDeclared, name, entry.isRequired ? undefined : entry.valueType));
         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,
-        });
+        types_1.FunctionType.addParameter(initOverride1, types_1.FunctionParam.create(2 /* ParameterCategory.KwargsDict */, entries.extraItems.valueType, types_1.FunctionParamFlags.TypeDeclared, 'kwargs'));
+        types_1.FunctionType.addParameter(initOverride2, types_1.FunctionParam.create(2 /* ParameterCategory.KwargsDict */, entries.extraItems.valueType, types_1.FunctionParamFlags.TypeDeclared, 'kwargs'));
     }
     const symbolTable = types_1.ClassType.getSymbolTable(classType);
     const initType = types_1.OverloadedFunctionType.create([initOverride1, initOverride2]);
@@ -251,27 +207,17 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType) {
     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 /* ParameterCategory.Simple */,
-            name: 'self',
-            type: types_1.ClassType.cloneAsInstance(classType),
-            hasDeclaredType: true,
-        };
+        const selfParam = types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, types_1.ClassType.cloneAsInstance(classType), types_1.FunctionParamFlags.TypeDeclared, 'self');
         function createDefaultTypeVar(func) {
             let defaultTypeVar = types_1.TypeVarType.createInstance(`__TDefault`);
-            defaultTypeVar = types_1.TypeVarType.cloneForScopeId(defaultTypeVar, func.details.typeVarScopeId, classType.details.name, 1 /* TypeVarScopeType.Function */);
+            defaultTypeVar = types_1.TypeVarType.cloneForScopeId(defaultTypeVar, func.shared.typeVarScopeId, classType.shared.name, 1 /* TypeVarScopeType.Function */);
             return defaultTypeVar;
         }
         function createGetMethod(keyType, valueType, includeDefault, isEntryRequired = false, defaultTypeMatchesField = false) {
             const getOverload = types_1.FunctionType.createSynthesizedInstance('get', 256 /* FunctionTypeFlags.Overloaded */);
             types_1.FunctionType.addParameter(getOverload, selfParam);
-            getOverload.details.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
-            types_1.FunctionType.addParameter(getOverload, {
-                category: 0 /* ParameterCategory.Simple */,
-                name: 'k',
-                type: keyType,
-                hasDeclaredType: true,
-            });
+            getOverload.shared.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
+            types_1.FunctionType.addParameter(getOverload, types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, keyType, types_1.FunctionParamFlags.TypeDeclared, 'k'));
             if (includeDefault) {
                 const defaultTypeVar = createDefaultTypeVar(getOverload);
                 let defaultParamType;
@@ -291,36 +237,26 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType) {
                     }
                     returnType = defaultParamType;
                 }
-                types_1.FunctionType.addParameter(getOverload, {
-                    category: 0 /* ParameterCategory.Simple */,
-                    name: 'default',
-                    type: defaultParamType,
-                    hasDeclaredType: true,
-                });
-                getOverload.details.declaredReturnType = returnType;
+                types_1.FunctionType.addParameter(getOverload, types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, defaultParamType, types_1.FunctionParamFlags.TypeDeclared, 'default'));
+                getOverload.shared.declaredReturnType = returnType;
             }
             else {
-                getOverload.details.declaredReturnType = isEntryRequired
+                getOverload.shared.declaredReturnType = isEntryRequired
                     ? valueType
                     : (0, types_1.combineTypes)([valueType, evaluator.getNoneType()]);
             }
             return getOverload;
         }
         function createPopMethods(keyType, valueType, isEntryRequired) {
-            const keyParam = {
-                category: 0 /* ParameterCategory.Simple */,
-                name: 'k',
-                type: keyType,
-                hasDeclaredType: true,
-            };
+            const keyParam = types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, keyType, types_1.FunctionParamFlags.TypeDeclared, 'k');
             const popOverload1 = types_1.FunctionType.createSynthesizedInstance('pop', 256 /* FunctionTypeFlags.Overloaded */);
             types_1.FunctionType.addParameter(popOverload1, selfParam);
             types_1.FunctionType.addParameter(popOverload1, keyParam);
-            popOverload1.details.declaredReturnType = valueType;
+            popOverload1.shared.declaredReturnType = valueType;
             const popOverload2 = types_1.FunctionType.createSynthesizedInstance('pop', 256 /* FunctionTypeFlags.Overloaded */);
             types_1.FunctionType.addParameter(popOverload2, selfParam);
             types_1.FunctionType.addParameter(popOverload2, keyParam);
-            popOverload2.details.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
+            popOverload2.shared.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
             const defaultTypeVar = createDefaultTypeVar(popOverload2);
             let defaultParamType;
             let returnType;
@@ -334,44 +270,23 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType) {
                 defaultParamType = (0, types_1.combineTypes)([valueType, defaultTypeVar]);
                 returnType = defaultParamType;
             }
-            types_1.FunctionType.addParameter(popOverload2, {
-                category: 0 /* ParameterCategory.Simple */,
-                name: 'default',
-                hasDeclaredType: true,
-                type: defaultParamType,
-                hasDefault: true,
-            });
-            popOverload2.details.declaredReturnType = returnType;
+            types_1.FunctionType.addParameter(popOverload2, types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, defaultParamType, types_1.FunctionParamFlags.TypeDeclared, 'default', defaultParamType));
+            popOverload2.shared.declaredReturnType = returnType;
             return [popOverload1, popOverload2];
         }
         function createSetDefaultMethod(keyType, valueType) {
             const setDefaultOverload = types_1.FunctionType.createSynthesizedInstance('setdefault', 256 /* FunctionTypeFlags.Overloaded */);
             types_1.FunctionType.addParameter(setDefaultOverload, selfParam);
-            types_1.FunctionType.addParameter(setDefaultOverload, {
-                category: 0 /* ParameterCategory.Simple */,
-                name: 'k',
-                hasDeclaredType: true,
-                type: keyType,
-            });
-            types_1.FunctionType.addParameter(setDefaultOverload, {
-                category: 0 /* ParameterCategory.Simple */,
-                name: 'default',
-                hasDeclaredType: true,
-                type: valueType,
-            });
-            setDefaultOverload.details.declaredReturnType = valueType;
+            types_1.FunctionType.addParameter(setDefaultOverload, types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, keyType, types_1.FunctionParamFlags.TypeDeclared, 'k'));
+            types_1.FunctionType.addParameter(setDefaultOverload, types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, valueType, types_1.FunctionParamFlags.TypeDeclared, 'default'));
+            setDefaultOverload.shared.declaredReturnType = valueType;
             return setDefaultOverload;
         }
         function createDelItemMethod(keyType) {
             const delItemOverload = types_1.FunctionType.createSynthesizedInstance('delitem', 256 /* FunctionTypeFlags.Overloaded */);
             types_1.FunctionType.addParameter(delItemOverload, selfParam);
-            types_1.FunctionType.addParameter(delItemOverload, {
-                category: 0 /* ParameterCategory.Simple */,
-                name: 'k',
-                hasDeclaredType: true,
-                type: keyType,
-            });
-            delItemOverload.details.declaredReturnType = evaluator.getNoneType();
+            types_1.FunctionType.addParameter(delItemOverload, types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, keyType, types_1.FunctionParamFlags.TypeDeclared, 'k'));
+            delItemOverload.shared.declaredReturnType = evaluator.getNoneType();
             return delItemOverload;
         }
         function createUpdateMethod() {
@@ -385,19 +300,14 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType) {
             const updateMethod3 = types_1.FunctionType.createSynthesizedInstance('update', 256 /* FunctionTypeFlags.Overloaded */);
             types_1.FunctionType.addParameter(updateMethod3, selfParam);
             // If all entries are read-only, don't allow updates.
-            types_1.FunctionType.addParameter(updateMethod1, {
-                category: 0 /* ParameterCategory.Simple */,
-                name: '__m',
-                hasDeclaredType: true,
-                type: allEntriesAreReadOnly
-                    ? types_1.NeverType.createNever()
-                    : types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForPartialTypedDict(classType)),
-            });
+            types_1.FunctionType.addParameter(updateMethod1, types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, allEntriesAreReadOnly
+                ? types_1.NeverType.createNever()
+                : types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForPartialTypedDict(classType)), types_1.FunctionParamFlags.TypeDeclared, '__m'));
             types_1.FunctionType.addPositionOnlyParameterSeparator(updateMethod1);
             types_1.FunctionType.addKeywordOnlyParameterSeparator(updateMethod3);
-            updateMethod1.details.declaredReturnType = evaluator.getNoneType();
-            updateMethod2.details.declaredReturnType = evaluator.getNoneType();
-            updateMethod3.details.declaredReturnType = evaluator.getNoneType();
+            updateMethod1.shared.declaredReturnType = evaluator.getNoneType();
+            updateMethod2.shared.declaredReturnType = evaluator.getNoneType();
+            updateMethod3.shared.declaredReturnType = evaluator.getNoneType();
             const tuplesToCombine = [];
             const tupleClass = evaluator.getBuiltInType(node, 'tuple');
             entries.knownItems.forEach((entry, name) => {
@@ -414,26 +324,14 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType) {
                         tuplesToCombine.push(tupleType);
                     }
                     // For writable entries, add a keyword argument.
-                    types_1.FunctionType.addParameter(updateMethod3, {
-                        category: 0 /* ParameterCategory.Simple */,
-                        name,
-                        hasDeclaredType: true,
-                        hasDefault: true,
-                        defaultType: types_1.AnyType.create(/* isEllipsis */ true),
-                        type: entry.valueType,
-                    });
+                    types_1.FunctionType.addParameter(updateMethod3, types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, entry.valueType, types_1.FunctionParamFlags.TypeDeclared, name, types_1.AnyType.create(/* isEllipsis */ true)));
                 }
             });
             const iterableClass = evaluator.getTypingType(node, 'Iterable');
             if (iterableClass && (0, types_1.isInstantiableClass)(iterableClass)) {
                 const iterableType = types_1.ClassType.cloneAsInstance(iterableClass);
-                types_1.FunctionType.addParameter(updateMethod2, {
-                    category: 0 /* ParameterCategory.Simple */,
-                    name: '__m',
-                    hasDeclaredType: true,
-                    type: types_1.ClassType.cloneForSpecialization(iterableType, [(0, types_1.combineTypes)(tuplesToCombine)], 
-                    /* isTypeArgumentExplicit */ true),
-                });
+                types_1.FunctionType.addParameter(updateMethod2, types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, types_1.ClassType.cloneForSpecialization(iterableType, [(0, types_1.combineTypes)(tuplesToCombine)], 
+                /* isTypeArgumentExplicit */ true), types_1.FunctionParamFlags.TypeDeclared, '__m'));
             }
             types_1.FunctionType.addPositionOnlyParameterSeparator(updateMethod2);
             // Note that the order of method1 and method2 is swapped. This is done so
@@ -492,7 +390,7 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType) {
         if (dictValueType) {
             const clearMethod = types_1.FunctionType.createSynthesizedInstance('clear');
             types_1.FunctionType.addParameter(clearMethod, selfParam);
-            clearMethod.details.declaredReturnType = evaluator.getNoneType();
+            clearMethod.shared.declaredReturnType = evaluator.getNoneType();
             symbolTable.set('clear', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, clearMethod));
             const popItemMethod = types_1.FunctionType.createSynthesizedInstance('popitem');
             types_1.FunctionType.addParameter(popItemMethod, selfParam);
@@ -507,7 +405,7 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType) {
             else {
                 tupleType = types_1.UnknownType.create();
             }
-            popItemMethod.details.declaredReturnType = tupleType;
+            popItemMethod.shared.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
@@ -520,8 +418,8 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType) {
                 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], 
+                    returnTypeClass.shared.typeParameters.length === 2) {
+                    method.shared.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));
                 }
@@ -533,7 +431,7 @@ exports.synthesizeTypedDictClassMethods = synthesizeTypedDictClassMethods;
 function getTypedDictMembersForClass(evaluator, classType, allowNarrowed = false) {
     var _a;
     // Were the entries already calculated and cached?
-    if (!classType.details.typedDictEntries) {
+    if (!classType.shared.typedDictEntries) {
         const entries = {
             knownItems: new Map(),
             extraItems: undefined,
@@ -548,17 +446,17 @@ function getTypedDictMembersForClass(evaluator, classType, allowNarrowed = false
             };
         }
         // Cache the entries for next time.
-        classType.details.typedDictEntries = entries;
+        classType.shared.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.knownItems.forEach((value, key) => {
+    classType.shared.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
         // read-only entries to Never.
-        if (classType.isTypedDictPartial) {
+        if (classType.priv.isTypedDictPartial) {
             tdEntry.isRequired = false;
             if (tdEntry.isReadOnly) {
                 tdEntry.valueType = types_1.NeverType.createNever();
@@ -570,8 +468,8 @@ function getTypedDictMembersForClass(evaluator, classType, allowNarrowed = false
         entries.set(key, tdEntry);
     });
     // Apply narrowed types on top of existing entries if present.
-    if (allowNarrowed && classType.typedDictNarrowedEntries) {
-        classType.typedDictNarrowedEntries.forEach((value, key) => {
+    if (allowNarrowed && classType.priv.typedDictNarrowedEntries) {
+        classType.priv.typedDictNarrowedEntries.forEach((value, key) => {
             const tdEntry = { ...value };
             tdEntry.valueType = (0, typeUtils_1.applySolvedTypeVars)(tdEntry.valueType, typeVarContext);
             entries.set(key, tdEntry);
@@ -579,7 +477,7 @@ function getTypedDictMembersForClass(evaluator, classType, allowNarrowed = false
     }
     return {
         knownItems: entries,
-        extraItems: (_a = classType.details.typedDictEntries) === null || _a === void 0 ? void 0 : _a.extraItems,
+        extraItems: (_a = classType.shared.typedDictEntries) === null || _a === void 0 ? void 0 : _a.extraItems,
     };
 }
 exports.getTypedDictMembersForClass = getTypedDictMembersForClass;
@@ -646,22 +544,22 @@ exports.getTypedDictDictEquivalent = getTypedDictDictEquivalent;
 function getTypedDictFieldsFromDictSyntax(evaluator, entryDict, classFields, isInline) {
     const entrySet = new Set();
     const fileInfo = AnalyzerNodeInfo.getFileInfo(entryDict);
-    entryDict.entries.forEach((entry) => {
+    entryDict.d.items.forEach((entry) => {
         if (entry.nodeType !== 20 /* ParseNodeType.DictionaryKeyEntry */) {
             evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictSecondArgDictEntry(), entry);
             return;
         }
-        if (entry.keyExpression.nodeType !== 48 /* ParseNodeType.StringList */) {
-            evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictEntryName(), entry.keyExpression);
+        if (entry.d.keyExpr.nodeType !== 48 /* ParseNodeType.StringList */) {
+            evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictEntryName(), entry.d.keyExpr);
             return;
         }
-        const entryName = entry.keyExpression.strings.map((s) => s.value).join('');
+        const entryName = entry.d.keyExpr.d.strings.map((s) => s.d.value).join('');
         if (!entryName) {
-            evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictEmptyName(), entry.keyExpression);
+            evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictEmptyName(), entry.d.keyExpr);
             return;
         }
         if (entrySet.has(entryName)) {
-            evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictEntryUnique(), entry.keyExpression);
+            evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictEntryUnique(), entry.d.keyExpr);
             return;
         }
         // Record names in a set to detect duplicates.
@@ -669,11 +567,11 @@ function getTypedDictFieldsFromDictSyntax(evaluator, entryDict, classFields, isI
         const newSymbol = new symbol_1.Symbol(8 /* SymbolFlags.InstanceMember */);
         const declaration = {
             type: 1 /* DeclarationType.Variable */,
-            node: entry.keyExpression,
+            node: entry.d.keyExpr,
             uri: fileInfo.fileUri,
-            typeAnnotationNode: entry.valueExpression,
+            typeAnnotationNode: entry.d.valueExpr,
             isRuntimeTypeExpression: !isInline,
-            range: (0, positionUtils_1.convertOffsetsToRange)(entry.keyExpression.start, textRange_1.TextRange.getEnd(entry.keyExpression), fileInfo.lines),
+            range: (0, positionUtils_1.convertOffsetsToRange)(entry.d.keyExpr.start, textRange_1.TextRange.getEnd(entry.d.keyExpr), fileInfo.lines),
             moduleName: fileInfo.moduleName,
             isInExceptSuite: false,
         };
@@ -690,9 +588,9 @@ function getTypedDictMembersForClassRecursive(evaluator, classType, entries, rec
         return;
     }
     recursionCount++;
-    classType.details.baseClasses.forEach((baseClassType) => {
+    classType.shared.baseClasses.forEach((baseClassType) => {
         if ((0, types_1.isInstantiableClass)(baseClassType) && types_1.ClassType.isTypedDictClass(baseClassType)) {
-            const specializedBaseClassType = (0, typeUtils_1.partiallySpecializeType)(baseClassType, classType);
+            const specializedBaseClassType = (0, typeUtils_1.partiallySpecializeType)(baseClassType, classType, evaluator.getTypeClassType());
             (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.
@@ -750,8 +648,8 @@ function getEffectiveExtraItemsEntryType(evaluator, classType) {
             isProvided: false,
         };
     }
-    if ((_a = classType.details.typedDictEntries) === null || _a === void 0 ? void 0 : _a.extraItems) {
-        return classType.details.typedDictEntries.extraItems;
+    if ((_a = classType.shared.typedDictEntries) === null || _a === void 0 ? void 0 : _a.extraItems) {
+        return classType.shared.typedDictEntries.extraItems;
     }
     return {
         valueType: types_1.NeverType.createNever(),
@@ -901,10 +799,10 @@ function assignToTypedDict(evaluator, classType, keyTypes, valueTypes, diagAdden
     const narrowedEntries = new Map();
     let typeVarContext;
     let genericClassType = classType;
-    if (classType.details.typeParameters.length > 0) {
+    if (classType.shared.typeParameters.length > 0) {
         typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(classType));
         // Create a generic (nonspecialized version) of the class.
-        if (classType.typeArguments) {
+        if (classType.priv.typeArguments) {
             genericClassType = types_1.ClassType.cloneForSpecialization(classType, 
             /* typeArguments */ undefined, 
             /* isTypeArgumentExplicit */ false);
@@ -917,7 +815,7 @@ function assignToTypedDict(evaluator, classType, keyTypes, valueTypes, diagAdden
             isMatch = false;
         }
         else {
-            const keyValue = keyType.literalValue;
+            const keyValue = keyType.priv.literalValue;
             const symbolEntry = tdEntries.knownItems.get(keyValue);
             if (!symbolEntry) {
                 if (tdEntries.extraItems) {
@@ -940,7 +838,7 @@ function assignToTypedDict(evaluator, classType, keyTypes, valueTypes, diagAdden
                     if (diagAddendum) {
                         const subDiag = diagAddendum === null || diagAddendum === void 0 ? void 0 : diagAddendum.createAddendum();
                         subDiag.addMessage(localize_1.LocAddendum.typedDictFieldUndefined().format({
-                            name: keyType.literalValue,
+                            name: keyType.priv.literalValue,
                             type: evaluator.printType(types_1.ClassType.cloneAsInstance(classType)),
                         }));
                         subDiag.addTextRange(keyTypeResult.node);
@@ -954,7 +852,7 @@ function assignToTypedDict(evaluator, classType, keyTypes, valueTypes, diagAdden
                 /* srcTypeVarContext */ undefined, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */)) {
                     if (subDiag) {
                         subDiag.addMessage(localize_1.LocAddendum.typedDictFieldTypeMismatch().format({
-                            name: keyType.literalValue,
+                            name: keyType.priv.literalValue,
                             type: evaluator.printType(valueTypes[index].type),
                         }));
                         subDiag.addTextRange(keyTypeResult.node);
@@ -1000,16 +898,16 @@ function assignToTypedDict(evaluator, classType, keyTypes, valueTypes, diagAdden
 }
 exports.assignToTypedDict = assignToTypedDict;
 function getTypeOfIndexedTypedDict(evaluator, node, baseType, usage) {
-    if (node.items.length !== 1) {
-        evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeArgsMismatchOne().format({ received: node.items.length }), node);
+    if (node.d.items.length !== 1) {
+        evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeArgsMismatchOne().format({ received: node.d.items.length }), node);
         return { 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 /* ArgumentCategory.Simple */) {
+    if (node.d.trailingComma || node.d.items[0].d.name || node.d.items[0].d.argCategory !== 0 /* ArgumentCategory.Simple */) {
         return undefined;
     }
     const entries = getTypedDictMembersForClass(evaluator, baseType, /* allowNarrowed */ usage.method === 'get');
-    const indexTypeResult = evaluator.getTypeOfExpression(node.items[0].valueExpression);
+    const indexTypeResult = evaluator.getTypeOfExpression(node.d.items[0].d.valueExpr);
     const indexType = indexTypeResult.type;
     let diag = new diagnostic_1.DiagnosticAddendum();
     let allDiagsInvolveNotRequiredKeys = true;
@@ -1019,13 +917,13 @@ function getTypeOfIndexedTypedDict(evaluator, node, baseType, usage) {
             return subtype;
         }
         if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'str')) {
-            if (subtype.literalValue === undefined) {
+            if (subtype.priv.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 entryName = subtype.priv.literalValue;
             const entry = (_a = entries.knownItems.get(entryName)) !== null && _a !== void 0 ? _a : entries.extraItems;
             if (!entry) {
                 diag.addMessage(localize_1.LocAddendum.keyUndefined().format({
@@ -1095,19 +993,19 @@ function narrowForKeyAssignment(classType, key) {
     // We should never be called if the classType is not a TypedDict or if typedDictEntries
     // is empty, but this can theoretically happen in the presence of certain circular
     // dependencies.
-    if (!types_1.ClassType.isTypedDictClass(classType) || !classType.details.typedDictEntries) {
+    if (!types_1.ClassType.isTypedDictClass(classType) || !classType.shared.typedDictEntries) {
         return classType;
     }
-    const tdEntry = classType.details.typedDictEntries.knownItems.get(key);
+    const tdEntry = classType.shared.typedDictEntries.knownItems.get(key);
     if (!tdEntry || tdEntry.isRequired) {
         return classType;
     }
-    const narrowedTdEntry = (_a = classType.typedDictNarrowedEntries) === null || _a === void 0 ? void 0 : _a.get(key);
+    const narrowedTdEntry = (_a = classType.priv.typedDictNarrowedEntries) === null || _a === void 0 ? void 0 : _a.get(key);
     if (narrowedTdEntry === null || narrowedTdEntry === void 0 ? void 0 : narrowedTdEntry.isProvided) {
         return classType;
     }
-    const narrowedEntries = classType.typedDictNarrowedEntries
-        ? new Map(classType.typedDictNarrowedEntries)
+    const narrowedEntries = classType.priv.typedDictNarrowedEntries
+        ? new Map(classType.priv.typedDictNarrowedEntries)
         : new Map();
     narrowedEntries.set(key, {
         isProvided: true,