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

package/dist/analyzer/dataClasses.js

@@ -56,34 +56,24 @@ function synthesizeDataClassMethods(evaluator, node, classType, isNamedTuple, sk
     (0, debug_1.assert)(types_1.ClassType.isDataClass(classType) || isNamedTuple);
     const classTypeVar = (0, typeUtils_1.synthesizeTypeVarForSelfCls)(classType, /* isClsParam */ true);
     const newType = types_1.FunctionType.createSynthesizedInstance('__new__', 1 /* FunctionTypeFlags.ConstructorMethod */);
-    newType.details.constructorTypeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(classType);
+    newType.priv.constructorTypeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(classType);
     const initType = types_1.FunctionType.createSynthesizedInstance('__init__');
-    initType.details.constructorTypeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(classType);
+    initType.priv.constructorTypeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(classType);
     // Generate both a __new__ and an __init__ method. The parameters of the
     // __new__ method are based on field definitions for NamedTuple classes,
     // and the parameters of the __init__ method are based on field definitions
     // in other cases.
-    types_1.FunctionType.addParameter(newType, {
-        category: 0 /* ParameterCategory.Simple */,
-        name: 'cls',
-        type: classTypeVar,
-        hasDeclaredType: true,
-    });
+    types_1.FunctionType.addParameter(newType, types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, classTypeVar, types_1.FunctionParamFlags.TypeDeclared, 'cls'));
     if (!isNamedTuple) {
         types_1.FunctionType.addDefaultParameters(newType);
     }
-    newType.details.declaredReturnType = (0, typeUtils_1.convertToInstance)(classTypeVar);
-    const selfParam = {
-        category: 0 /* ParameterCategory.Simple */,
-        name: 'self',
-        type: (0, typeUtils_1.synthesizeTypeVarForSelfCls)(classType, /* isClsParam */ false),
-        hasDeclaredType: true,
-    };
+    newType.shared.declaredReturnType = (0, typeUtils_1.convertToInstance)(classTypeVar);
+    const selfParam = types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, (0, typeUtils_1.synthesizeTypeVarForSelfCls)(classType, /* isClsParam */ false), types_1.FunctionParamFlags.TypeDeclared, 'self');
     types_1.FunctionType.addParameter(initType, selfParam);
     if (isNamedTuple) {
         types_1.FunctionType.addDefaultParameters(initType);
     }
-    initType.details.declaredReturnType = evaluator.getNoneType();
+    initType.shared.declaredReturnType = evaluator.getNoneType();
     // Maintain a list of all dataclass entries (including
     // those from inherited classes) plus a list of only those
     // entries added by this class.
@@ -144,89 +134,81 @@ function synthesizeDataClassMethods(evaluator, node, classType, isNamedTuple, sk
             let variableTypeEvaluator;
             let hasDefaultValue = false;
             let isKeywordOnly = types_1.ClassType.isDataClassKeywordOnly(classType) || sawKeywordOnlySeparator;
-            let defaultValueExpression;
             let includeInInit = true;
             let converter;
             if (statement.nodeType === 3 /* ParseNodeType.Assignment */) {
-                if (statement.leftExpression.nodeType === 54 /* ParseNodeType.TypeAnnotation */ &&
-                    statement.leftExpression.valueExpression.nodeType === 38 /* ParseNodeType.Name */) {
-                    variableNameNode = statement.leftExpression.valueExpression;
+                if (statement.d.leftExpr.nodeType === 54 /* ParseNodeType.TypeAnnotation */ &&
+                    statement.d.leftExpr.d.valueExpr.nodeType === 38 /* ParseNodeType.Name */) {
+                    variableNameNode = statement.d.leftExpr.d.valueExpr;
                     const assignmentStatement = statement;
-                    variableTypeEvaluator = () => evaluator.getTypeOfAnnotation(assignmentStatement.leftExpression.typeAnnotation, {
+                    variableTypeEvaluator = () => evaluator.getTypeOfAnnotation(assignmentStatement.d.leftExpr.d.annotation, {
                         isVariableAnnotation: true,
                         allowFinal: true,
                         allowClassVar: true,
                     });
                 }
                 hasDefaultValue = true;
-                defaultValueExpression = statement.rightExpression;
                 // If the RHS of the assignment is assigning a field instance where the
                 // "init" parameter is set to false, do not include it in the init method.
-                if (statement.rightExpression.nodeType === 9 /* ParseNodeType.Call */) {
-                    const callTypeResult = evaluator.getTypeOfExpression(statement.rightExpression.leftExpression, 2 /* EvalFlags.CallBaseDefaults */);
+                if (statement.d.rightExpr.nodeType === 9 /* ParseNodeType.Call */) {
+                    const callTypeResult = evaluator.getTypeOfExpression(statement.d.rightExpr.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */);
                     const callType = callTypeResult.type;
                     if (!isNamedTuple &&
-                        isDataclassFieldConstructor(callType, ((_b = classType.details.dataClassBehaviors) === null || _b === void 0 ? void 0 : _b.fieldDescriptorNames) || [])) {
-                        const initArg = statement.rightExpression.arguments.find((arg) => { var _a; return ((_a = arg.name) === null || _a === void 0 ? void 0 : _a.value) === 'init'; });
-                        if (initArg && initArg.valueExpression) {
+                        isDataclassFieldConstructor(callType, ((_b = classType.shared.dataClassBehaviors) === null || _b === void 0 ? void 0 : _b.fieldDescriptorNames) || [])) {
+                        const initArg = statement.d.rightExpr.d.args.find((arg) => { var _a; return ((_a = arg.d.name) === null || _a === void 0 ? void 0 : _a.d.value) === 'init'; });
+                        if (initArg && initArg.d.valueExpr) {
                             const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
                             includeInInit =
-                                (_c = (0, staticExpressions_1.evaluateStaticBoolExpression)(initArg.valueExpression, fileInfo.executionEnvironment, fileInfo.definedConstants)) !== null && _c !== void 0 ? _c : includeInInit;
+                                (_c = (0, staticExpressions_1.evaluateStaticBoolExpression)(initArg.d.valueExpr, fileInfo.executionEnvironment, fileInfo.definedConstants)) !== null && _c !== void 0 ? _c : includeInInit;
                         }
                         else {
                             includeInInit =
-                                (_d = getDefaultArgValueForFieldSpecifier(evaluator, statement.rightExpression, callTypeResult, 'init')) !== null && _d !== void 0 ? _d : includeInInit;
+                                (_d = getDefaultArgValueForFieldSpecifier(evaluator, statement.d.rightExpr, callTypeResult, 'init')) !== null && _d !== void 0 ? _d : includeInInit;
                         }
-                        const kwOnlyArg = statement.rightExpression.arguments.find((arg) => { var _a; return ((_a = arg.name) === null || _a === void 0 ? void 0 : _a.value) === 'kw_only'; });
-                        if (kwOnlyArg && kwOnlyArg.valueExpression) {
+                        const kwOnlyArg = statement.d.rightExpr.d.args.find((arg) => { var _a; return ((_a = arg.d.name) === null || _a === void 0 ? void 0 : _a.d.value) === 'kw_only'; });
+                        if (kwOnlyArg && kwOnlyArg.d.valueExpr) {
                             const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
                             isKeywordOnly =
-                                (_e = (0, staticExpressions_1.evaluateStaticBoolExpression)(kwOnlyArg.valueExpression, fileInfo.executionEnvironment, fileInfo.definedConstants)) !== null && _e !== void 0 ? _e : isKeywordOnly;
+                                (_e = (0, staticExpressions_1.evaluateStaticBoolExpression)(kwOnlyArg.d.valueExpr, fileInfo.executionEnvironment, fileInfo.definedConstants)) !== null && _e !== void 0 ? _e : isKeywordOnly;
                         }
                         else {
                             isKeywordOnly =
-                                (_f = getDefaultArgValueForFieldSpecifier(evaluator, statement.rightExpression, callTypeResult, 'kw_only')) !== null && _f !== void 0 ? _f : isKeywordOnly;
+                                (_f = getDefaultArgValueForFieldSpecifier(evaluator, statement.d.rightExpr, callTypeResult, 'kw_only')) !== null && _f !== void 0 ? _f : isKeywordOnly;
                         }
-                        const defaultArg = statement.rightExpression.arguments.find((arg) => {
+                        const defaultArg = statement.d.rightExpr.d.args.find((arg) => {
                             var _a, _b, _c;
-                            return ((_a = arg.name) === null || _a === void 0 ? void 0 : _a.value) === 'default' ||
-                                ((_b = arg.name) === null || _b === void 0 ? void 0 : _b.value) === 'default_factory' ||
-                                ((_c = arg.name) === null || _c === void 0 ? void 0 : _c.value) === 'factory';
+                            return ((_a = arg.d.name) === null || _a === void 0 ? void 0 : _a.d.value) === 'default' ||
+                                ((_b = arg.d.name) === null || _b === void 0 ? void 0 : _b.d.value) === 'default_factory' ||
+                                ((_c = arg.d.name) === null || _c === void 0 ? void 0 : _c.d.value) === 'factory';
                         });
                         hasDefaultValue = !!defaultArg;
-                        if (defaultArg === null || defaultArg === void 0 ? void 0 : defaultArg.valueExpression) {
-                            defaultValueExpression = defaultArg.valueExpression;
-                        }
-                        const aliasArg = statement.rightExpression.arguments.find((arg) => { var _a; return ((_a = arg.name) === null || _a === void 0 ? void 0 : _a.value) === 'alias'; });
+                        const aliasArg = statement.d.rightExpr.d.args.find((arg) => { var _a; return ((_a = arg.d.name) === null || _a === void 0 ? void 0 : _a.d.value) === 'alias'; });
                         if (aliasArg) {
-                            const valueType = evaluator.getTypeOfExpression(aliasArg.valueExpression).type;
+                            const valueType = evaluator.getTypeOfExpression(aliasArg.d.valueExpr).type;
                             if ((0, types_1.isClassInstance)(valueType) &&
                                 types_1.ClassType.isBuiltIn(valueType, 'str') &&
                                 (0, typeUtils_1.isLiteralType)(valueType)) {
-                                aliasName = valueType.literalValue;
+                                aliasName = valueType.priv.literalValue;
                             }
                         }
-                        const converterArg = statement.rightExpression.arguments.find((arg) => { var _a; return ((_a = arg.name) === null || _a === void 0 ? void 0 : _a.value) === 'converter'; });
-                        if (converterArg && converterArg.valueExpression) {
-                            // Converter support is dependent on PEP 712, which has not yet been approved.
-                            if (AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures) {
-                                converter = converterArg;
-                            }
+                        const converterArg = statement.d.rightExpr.d.args.find((arg) => { var _a; return ((_a = arg.d.name) === null || _a === void 0 ? void 0 : _a.d.value) === 'converter'; });
+                        if (converterArg && converterArg.d.valueExpr) {
+                            converter = converterArg;
                         }
                     }
                 }
             }
             else if (statement.nodeType === 54 /* ParseNodeType.TypeAnnotation */) {
-                if (statement.valueExpression.nodeType === 38 /* ParseNodeType.Name */) {
-                    variableNameNode = statement.valueExpression;
+                if (statement.d.valueExpr.nodeType === 38 /* ParseNodeType.Name */) {
+                    variableNameNode = statement.d.valueExpr;
                     const annotationStatement = statement;
-                    variableTypeEvaluator = () => evaluator.getTypeOfAnnotation(annotationStatement.typeAnnotation, {
+                    variableTypeEvaluator = () => evaluator.getTypeOfAnnotation(annotationStatement.d.annotation, {
                         isVariableAnnotation: true,
                         allowFinal: true,
                         allowClassVar: true,
                     });
                     // Is this a KW_ONLY separator introduced in Python 3.10?
-                    if (!isNamedTuple && statement.valueExpression.value === '_') {
+                    if (!isNamedTuple && statement.d.valueExpr.d.value === '_') {
                         const annotatedType = variableTypeEvaluator();
                         if ((0, types_1.isClassInstance)(annotatedType) && types_1.ClassType.isBuiltIn(annotatedType, 'KW_ONLY')) {
                             sawKeywordOnlySeparator = true;
@@ -237,7 +219,7 @@ function synthesizeDataClassMethods(evaluator, node, classType, isNamedTuple, sk
                 }
             }
             if (variableNameNode && variableTypeEvaluator) {
-                const variableName = variableNameNode.value;
+                const variableName = variableNameNode.d.value;
                 // Don't include class vars. PEP 557 indicates that they shouldn't
                 // be considered data class entries.
                 const variableSymbol = types_1.ClassType.getSymbolTable(classType).get(variableName);
@@ -256,7 +238,6 @@ function synthesizeDataClassMethods(evaluator, node, classType, isNamedTuple, sk
                         alias: aliasName,
                         isKeywordOnly: false,
                         hasDefault: hasDefaultValue,
-                        defaultValueExpression,
                         includeInInit,
                         nameNode: variableNameNode,
                         type: types_1.UnknownType.create(),
@@ -275,7 +256,6 @@ function synthesizeDataClassMethods(evaluator, node, classType, isNamedTuple, sk
                         alias: aliasName,
                         isKeywordOnly,
                         hasDefault: hasDefaultValue,
-                        defaultValueExpression,
                         includeInInit,
                         nameNode: variableNameNode,
                         type: types_1.UnknownType.create(),
@@ -299,7 +279,6 @@ function synthesizeDataClassMethods(evaluator, node, classType, isNamedTuple, sk
                         // causes overridden variables to "inherit" default values from parent classes.
                         if (!dataClassEntry.hasDefault && oldEntry.hasDefault && oldEntry.includeInInit) {
                             dataClassEntry.hasDefault = true;
-                            dataClassEntry.defaultValueExpression = oldEntry.defaultValueExpression;
                             hasDefaultValue = true;
                             // Warn the user of this case because it can result in type errors if the
                             // default value is incompatible with the new type.
@@ -340,16 +319,16 @@ function synthesizeDataClassMethods(evaluator, node, classType, isNamedTuple, sk
             }
             // If the RHS of the assignment is assigning a field instance where the
             // "init" parameter is set to false, do not include it in the init method.
-            if (statement.rightExpression.nodeType === 9 /* ParseNodeType.Call */) {
-                const callType = evaluator.getTypeOfExpression(statement.rightExpression.leftExpression, 2 /* EvalFlags.CallBaseDefaults */).type;
-                if (isDataclassFieldConstructor(callType, ((_g = classType.details.dataClassBehaviors) === null || _g === void 0 ? void 0 : _g.fieldDescriptorNames) || [])) {
-                    evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassFieldWithoutAnnotation(), statement.rightExpression);
+            if (statement.d.rightExpr.nodeType === 9 /* ParseNodeType.Call */) {
+                const callType = evaluator.getTypeOfExpression(statement.d.rightExpr.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */).type;
+                if (isDataclassFieldConstructor(callType, ((_g = classType.shared.dataClassBehaviors) === null || _g === void 0 ? void 0 : _g.fieldDescriptorNames) || [])) {
+                    evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassFieldWithoutAnnotation(), statement.d.rightExpr);
                 }
             }
         }
     });
     if (!isNamedTuple) {
-        classType.details.dataClassEntries = localDataClassEntries;
+        classType.shared.dataClassEntries = localDataClassEntries;
     }
     // Now that the dataClassEntries field has been set with a complete list
     // of local data class entries for this class, perform deferred type
@@ -382,17 +361,10 @@ function synthesizeDataClassMethods(evaluator, node, classType, isNamedTuple, sk
                         symbolTable.set(entry.name, getDescriptorForConverterField(evaluator, node, entry.converter, entry.name, fieldType, effectiveType));
                     }
                     const effectiveName = entry.alias || entry.name;
-                    if (!entry.alias && entry.nameNode && (0, symbolNameUtils_1.isPrivateName)(entry.nameNode.value)) {
+                    if (!entry.alias && entry.nameNode && (0, symbolNameUtils_1.isPrivateName)(entry.nameNode.d.value)) {
                         evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassFieldWithPrivateName(), entry.nameNode);
                     }
-                    const functionParam = {
-                        category: 0 /* ParameterCategory.Simple */,
-                        name: effectiveName,
-                        hasDefault: entry.hasDefault,
-                        defaultValueExpression: entry.defaultValueExpression,
-                        type: effectiveType,
-                        hasDeclaredType: true,
-                    };
+                    const functionParam = types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, effectiveType, types_1.FunctionParamFlags.TypeDeclared, effectiveName, entry.hasDefault ? entry.type : undefined);
                     if (entry.isKeywordOnly) {
                         keywordOnlyParams.push(functionParam);
                     }
@@ -435,13 +407,8 @@ function synthesizeDataClassMethods(evaluator, node, classType, isNamedTuple, sk
     const synthesizeComparisonMethod = (operator, paramType) => {
         const operatorMethod = types_1.FunctionType.createSynthesizedInstance(operator);
         types_1.FunctionType.addParameter(operatorMethod, selfParam);
-        types_1.FunctionType.addParameter(operatorMethod, {
-            category: 0 /* ParameterCategory.Simple */,
-            name: 'other',
-            type: paramType,
-            hasDeclaredType: true,
-        });
-        operatorMethod.details.declaredReturnType = evaluator.getBuiltInObject(node, 'bool');
+        types_1.FunctionType.addParameter(operatorMethod, types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, paramType, types_1.FunctionParamFlags.TypeDeclared, 'other'));
+        operatorMethod.shared.declaredReturnType = evaluator.getBuiltInObject(node, 'bool');
         // If a method of this name already exists, don't override it.
         if (!symbolTable.get(operator)) {
             symbolTable.set(operator, symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, operatorMethod));
@@ -470,7 +437,7 @@ function synthesizeDataClassMethods(evaluator, node, classType, isNamedTuple, sk
     if (synthesizeHashFunction) {
         const hashMethod = types_1.FunctionType.createSynthesizedInstance('__hash__');
         types_1.FunctionType.addParameter(hashMethod, selfParam);
-        hashMethod.details.declaredReturnType = evaluator.getBuiltInObject(node, 'int');
+        hashMethod.shared.declaredReturnType = evaluator.getBuiltInObject(node, 'int');
         symbolTable.set('__hash__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */ | 4096 /* SymbolFlags.IgnoredForOverrideChecks */, hashMethod));
     }
     else if (synthesizeHashNone && !skipSynthesizeHash) {
@@ -484,8 +451,8 @@ function synthesizeDataClassMethods(evaluator, node, classType, isNamedTuple, sk
     if (!isNamedTuple) {
         symbolTable.set('__dataclass_fields__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */ | 128 /* SymbolFlags.ClassVar */, dictType));
     }
-    if (types_1.ClassType.isDataClassGenerateSlots(classType) && classType.details.localSlotsNames === undefined) {
-        classType.details.localSlotsNames = localDataClassEntries.map((entry) => entry.name);
+    if (types_1.ClassType.isDataClassGenerateSlots(classType) && classType.shared.localSlotsNames === undefined) {
+        classType.shared.localSlotsNames = localDataClassEntries.map((entry) => entry.name);
     }
     // Should we synthesize a __slots__ symbol?
     if (types_1.ClassType.isDataClassGenerateSlots(classType)) {
@@ -516,7 +483,7 @@ function getDefaultArgValueForFieldSpecifier(evaluator, callNode, callTypeResult
         callTarget = callType;
     }
     else if ((0, types_1.isOverloadedFunction)(callType)) {
-        callTarget = evaluator.getBestOverloadForArguments(callNode, { type: callType, isIncomplete: callTypeResult.isIncomplete }, callNode.arguments);
+        callTarget = evaluator.getBestOverloadForArguments(callNode, { type: callType, isIncomplete: callTypeResult.isIncomplete }, callNode.d.args.map((arg) => (0, typeUtils_1.convertArgumentNodeToFunctionArgument)(arg)));
     }
     else if ((0, types_1.isInstantiableClass)(callType)) {
         const initMethodResult = (0, constructors_1.getBoundInitMethod)(evaluator, callNode, callType);
@@ -525,25 +492,24 @@ function getDefaultArgValueForFieldSpecifier(evaluator, callNode, callTypeResult
                 callTarget = initMethodResult.type;
             }
             else if ((0, types_1.isOverloadedFunction)(initMethodResult.type)) {
-                callTarget = evaluator.getBestOverloadForArguments(callNode, { type: initMethodResult.type }, callNode.arguments);
+                callTarget = evaluator.getBestOverloadForArguments(callNode, { type: initMethodResult.type }, callNode.d.args.map((arg) => (0, typeUtils_1.convertArgumentNodeToFunctionArgument)(arg)));
             }
         }
     }
     if (callTarget) {
-        const initParam = callTarget.details.parameters.find((p) => p.name === paramName);
+        const initParam = callTarget.shared.parameters.find((p) => p.name === paramName);
         if (initParam) {
             // Is the parameter type a literal bool?
-            if (initParam.hasDeclaredType &&
+            if (types_1.FunctionParam.isTypeDeclared(initParam) &&
                 (0, types_1.isClass)(initParam.type) &&
-                typeof initParam.type.literalValue === 'boolean') {
-                return initParam.type.literalValue;
+                typeof initParam.type.priv.literalValue === 'boolean') {
+                return initParam.type.priv.literalValue;
             }
             // Is the default argument value a literal bool?
-            if (initParam.defaultValueExpression &&
-                initParam.defaultType &&
+            if (initParam.defaultType &&
                 (0, types_1.isClass)(initParam.defaultType) &&
-                typeof initParam.defaultType.literalValue === 'boolean') {
-                return initParam.defaultType.literalValue;
+                typeof initParam.defaultType.priv.literalValue === 'boolean') {
+                return initParam.defaultType.priv.literalValue;
             }
         }
     }
@@ -553,23 +519,18 @@ function getDefaultArgValueForFieldSpecifier(evaluator, callNode, callTypeResult
 // fieldType is returned.
 function getConverterInputType(evaluator, converterNode, fieldType, fieldName) {
     var _a;
-    const converterType = getConverterAsFunction(evaluator, evaluator.getTypeOfExpression(converterNode.valueExpression).type);
+    const converterType = getConverterAsFunction(evaluator, evaluator.getTypeOfExpression(converterNode.d.valueExpr).type);
     if (!converterType) {
         return fieldType;
     }
     // Create synthesized function of the form Callable[[T], fieldType] which
     // will be used to check compatibility of the provided converter.
     const typeVar = types_1.TypeVarType.createInstance('__converterInput');
-    typeVar.scopeId = (0, parseTreeUtils_1.getScopeIdForNode)(converterNode);
+    typeVar.priv.scopeId = (0, parseTreeUtils_1.getScopeIdForNode)(converterNode);
     const targetFunction = types_1.FunctionType.createSynthesizedInstance('');
-    targetFunction.details.typeVarScopeId = typeVar.scopeId;
-    targetFunction.details.declaredReturnType = fieldType;
-    types_1.FunctionType.addParameter(targetFunction, {
-        category: 0 /* ParameterCategory.Simple */,
-        name: '__input',
-        type: typeVar,
-        hasDeclaredType: true,
-    });
+    targetFunction.shared.typeVarScopeId = typeVar.priv.scopeId;
+    targetFunction.shared.declaredReturnType = fieldType;
+    types_1.FunctionType.addParameter(targetFunction, types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, typeVar, types_1.FunctionParamFlags.TypeDeclared | types_1.FunctionParamFlags.NameSynthesized, '__input'));
     types_1.FunctionType.addPositionOnlyParameterSeparator(targetFunction);
     if ((0, types_1.isFunction)(converterType) || (0, types_1.isOverloadedFunction)(converterType)) {
         const acceptedTypes = [];
@@ -581,7 +542,7 @@ function getConverterInputType(evaluator, converterNode, fieldType, fieldName) {
             /* diag */ undefined, returnTypeVarContext)) {
                 signature = (0, typeUtils_1.applySolvedTypeVars)(signature, returnTypeVarContext);
             }
-            const inputTypeVarContext = new typeVarContext_1.TypeVarContext(typeVar.scopeId);
+            const inputTypeVarContext = new typeVarContext_1.TypeVarContext(typeVar.priv.scopeId);
             if (evaluator.assignType(targetFunction, signature, diagAddendum, inputTypeVarContext)) {
                 const overloadSolution = (0, typeUtils_1.applySolvedTypeVars)(typeVar, inputTypeVarContext, {
                     unknownIfNotFound: true,
@@ -602,7 +563,7 @@ function getConverterInputType(evaluator, converterNode, fieldType, fieldName) {
         }
         else {
             evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassConverterOverloads().format({
-                funcName: converterType.overloads[0].details.name || '<anonymous function>',
+                funcName: converterType.priv.overloads[0].shared.name || '<anonymous function>',
                 fieldType: evaluator.printType(fieldType),
                 fieldName: fieldName,
             }) + diagAddendum.getString(), converterNode);
@@ -624,7 +585,7 @@ function getConverterAsFunction(evaluator, converterType) {
             // choose the first of the two subtypes, which typically corresponds
             // to the __init__ method (rather than the __new__ method).
             if ((0, types_1.isUnion)(fromConstructor)) {
-                fromConstructor = fromConstructor.subtypes[0];
+                fromConstructor = fromConstructor.priv.subtypes[0];
             }
             if ((0, types_1.isFunction)(fromConstructor) || (0, types_1.isOverloadedFunction)(fromConstructor)) {
                 return fromConstructor;
@@ -644,52 +605,22 @@ function getDescriptorForConverterField(evaluator, dataclassNode, converterNode,
     const descriptorName = `__converterDescriptor_${fieldName}`;
     const descriptorClass = types_1.ClassType.createInstantiable(descriptorName, (0, parseTreeUtils_1.getClassFullName)(converterNode, fileInfo.moduleName, descriptorName), fileInfo.moduleName, fileInfo.fileUri, 0 /* ClassTypeFlags.None */, (0, parseTreeUtils_1.getTypeSourceId)(converterNode), 
     /* declaredMetaclass */ undefined, (0, types_1.isInstantiableClass)(typeMetaclass) ? typeMetaclass : types_1.UnknownType.create());
-    descriptorClass.details.baseClasses.push(evaluator.getBuiltInType(dataclassNode, 'object'));
+    descriptorClass.shared.baseClasses.push(evaluator.getBuiltInType(dataclassNode, 'object'));
     (0, typeUtils_1.computeMroLinearization)(descriptorClass);
     const fields = types_1.ClassType.getSymbolTable(descriptorClass);
     const selfType = (0, typeUtils_1.synthesizeTypeVarForSelfCls)(descriptorClass, /* isClsParam */ false);
     const setFunction = types_1.FunctionType.createSynthesizedInstance('__set__');
-    types_1.FunctionType.addParameter(setFunction, {
-        category: 0 /* ParameterCategory.Simple */,
-        name: 'self',
-        type: selfType,
-        hasDeclaredType: true,
-    });
-    types_1.FunctionType.addParameter(setFunction, {
-        category: 0 /* ParameterCategory.Simple */,
-        name: 'obj',
-        type: types_1.AnyType.create(),
-        hasDeclaredType: true,
-    });
-    types_1.FunctionType.addParameter(setFunction, {
-        category: 0 /* ParameterCategory.Simple */,
-        name: 'value',
-        type: setType,
-        hasDeclaredType: true,
-    });
-    setFunction.details.declaredReturnType = evaluator.getNoneType();
+    types_1.FunctionType.addParameter(setFunction, types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, selfType, types_1.FunctionParamFlags.TypeDeclared, 'self'));
+    types_1.FunctionType.addParameter(setFunction, types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, types_1.AnyType.create(), types_1.FunctionParamFlags.TypeDeclared, 'obj'));
+    types_1.FunctionType.addParameter(setFunction, types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, setType, types_1.FunctionParamFlags.TypeDeclared, 'value'));
+    setFunction.shared.declaredReturnType = evaluator.getNoneType();
     const setSymbol = symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, setFunction);
     fields.set('__set__', setSymbol);
     const getFunction = types_1.FunctionType.createSynthesizedInstance('__get__');
-    types_1.FunctionType.addParameter(getFunction, {
-        category: 0 /* ParameterCategory.Simple */,
-        name: 'self',
-        type: selfType,
-        hasDeclaredType: true,
-    });
-    types_1.FunctionType.addParameter(getFunction, {
-        category: 0 /* ParameterCategory.Simple */,
-        name: 'obj',
-        type: types_1.AnyType.create(),
-        hasDeclaredType: true,
-    });
-    types_1.FunctionType.addParameter(getFunction, {
-        category: 0 /* ParameterCategory.Simple */,
-        name: 'objtype',
-        type: types_1.AnyType.create(),
-        hasDeclaredType: true,
-    });
-    getFunction.details.declaredReturnType = getType;
+    types_1.FunctionType.addParameter(getFunction, types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, selfType, types_1.FunctionParamFlags.TypeDeclared, 'self'));
+    types_1.FunctionType.addParameter(getFunction, types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, types_1.AnyType.create(), types_1.FunctionParamFlags.TypeDeclared, 'obj'));
+    types_1.FunctionType.addParameter(getFunction, types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, types_1.AnyType.create(), types_1.FunctionParamFlags.TypeDeclared, 'objtype'));
+    getFunction.shared.declaredReturnType = getType;
     const getSymbol = symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, getFunction);
     fields.set('__get__', getSymbol);
     return symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, types_1.ClassType.cloneAsInstance(descriptorClass));
@@ -754,13 +685,13 @@ exports.addInheritedDataClassEntries = addInheritedDataClassEntries;
 function isDataclassFieldConstructor(type, fieldDescriptorNames) {
     let callName;
     if ((0, types_1.isFunction)(type)) {
-        callName = type.details.fullName;
+        callName = type.shared.fullName;
     }
     else if ((0, types_1.isOverloadedFunction)(type)) {
-        callName = type.overloads[0].details.fullName;
+        callName = type.priv.overloads[0].shared.fullName;
     }
     else if ((0, types_1.isInstantiableClass)(type)) {
-        callName = type.details.fullName;
+        callName = type.shared.fullName;
     }
     if (!callName) {
         return false;
@@ -781,43 +712,43 @@ function validateDataClassTransformDecorator(evaluator, node) {
     };
     const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
     // Parse the arguments to the call.
-    node.arguments.forEach((arg) => {
-        if (!arg.name || arg.argumentCategory !== 0 /* ArgumentCategory.Simple */) {
+    node.d.args.forEach((arg) => {
+        if (!arg.d.name || arg.d.argCategory !== 0 /* ArgumentCategory.Simple */) {
             evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.dataClassTransformPositionalParam(), arg);
             return;
         }
-        switch (arg.name.value) {
+        switch (arg.d.name.d.value) {
             case 'kw_only_default': {
-                const value = (0, staticExpressions_1.evaluateStaticBoolExpression)(arg.valueExpression, fileInfo.executionEnvironment, fileInfo.definedConstants);
+                const value = (0, staticExpressions_1.evaluateStaticBoolExpression)(arg.d.valueExpr, fileInfo.executionEnvironment, fileInfo.definedConstants);
                 if (value === undefined) {
-                    evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassTransformExpectedBoolLiteral(), arg.valueExpression);
+                    evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassTransformExpectedBoolLiteral(), arg.d.valueExpr);
                     return;
                 }
                 behaviors.keywordOnly = value;
                 break;
             }
             case 'eq_default': {
-                const value = (0, staticExpressions_1.evaluateStaticBoolExpression)(arg.valueExpression, fileInfo.executionEnvironment, fileInfo.definedConstants);
+                const value = (0, staticExpressions_1.evaluateStaticBoolExpression)(arg.d.valueExpr, fileInfo.executionEnvironment, fileInfo.definedConstants);
                 if (value === undefined) {
-                    evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassTransformExpectedBoolLiteral(), arg.valueExpression);
+                    evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassTransformExpectedBoolLiteral(), arg.d.valueExpr);
                     return;
                 }
                 behaviors.skipGenerateEq = !value;
                 break;
             }
             case 'order_default': {
-                const value = (0, staticExpressions_1.evaluateStaticBoolExpression)(arg.valueExpression, fileInfo.executionEnvironment, fileInfo.definedConstants);
+                const value = (0, staticExpressions_1.evaluateStaticBoolExpression)(arg.d.valueExpr, fileInfo.executionEnvironment, fileInfo.definedConstants);
                 if (value === undefined) {
-                    evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassTransformExpectedBoolLiteral(), arg.valueExpression);
+                    evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassTransformExpectedBoolLiteral(), arg.d.valueExpr);
                     return;
                 }
                 behaviors.generateOrder = value;
                 break;
             }
             case 'frozen_default': {
-                const value = (0, staticExpressions_1.evaluateStaticBoolExpression)(arg.valueExpression, fileInfo.executionEnvironment, fileInfo.definedConstants);
+                const value = (0, staticExpressions_1.evaluateStaticBoolExpression)(arg.d.valueExpr, fileInfo.executionEnvironment, fileInfo.definedConstants);
                 if (value === undefined) {
-                    evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassTransformExpectedBoolLiteral(), arg.valueExpression);
+                    evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassTransformExpectedBoolLiteral(), arg.d.valueExpr);
                     return;
                 }
                 behaviors.frozen = value;
@@ -833,30 +764,30 @@ function validateDataClassTransformDecorator(evaluator, node) {
             // form that supported this older parameter name.
             case 'field_descriptors':
             case 'field_specifiers': {
-                const valueType = evaluator.getTypeOfExpression(arg.valueExpression).type;
+                const valueType = evaluator.getTypeOfExpression(arg.d.valueExpr).type;
                 if (!(0, types_1.isClassInstance)(valueType) ||
                     !types_1.ClassType.isBuiltIn(valueType, 'tuple') ||
-                    !valueType.tupleTypeArguments ||
-                    valueType.tupleTypeArguments.some((entry) => !(0, types_1.isInstantiableClass)(entry.type) &&
+                    !valueType.priv.tupleTypeArguments ||
+                    valueType.priv.tupleTypeArguments.some((entry) => !(0, types_1.isInstantiableClass)(entry.type) &&
                         !(0, types_1.isFunction)(entry.type) &&
                         !(0, types_1.isOverloadedFunction)(entry.type))) {
                     evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassTransformFieldSpecifier().format({
                         type: evaluator.printType(valueType),
-                    }), arg.valueExpression);
+                    }), arg.d.valueExpr);
                     return;
                 }
-                valueType.tupleTypeArguments.forEach((arg) => {
+                valueType.priv.tupleTypeArguments.forEach((arg) => {
                     if ((0, types_1.isInstantiableClass)(arg.type) || (0, types_1.isFunction)(arg.type)) {
-                        behaviors.fieldDescriptorNames.push(arg.type.details.fullName);
+                        behaviors.fieldDescriptorNames.push(arg.type.shared.fullName);
                     }
                     else if ((0, types_1.isOverloadedFunction)(arg.type)) {
-                        behaviors.fieldDescriptorNames.push(arg.type.overloads[0].details.fullName);
+                        behaviors.fieldDescriptorNames.push(arg.type.priv.overloads[0].shared.fullName);
                     }
                 });
                 break;
             }
             default:
-                evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassTransformUnknownArgument().format({ name: arg.name.value }), arg.valueExpression);
+                evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassTransformUnknownArgument().format({ name: arg.d.name.d.value }), arg.d.valueExpr);
                 break;
         }
     });
@@ -874,16 +805,16 @@ function getDataclassDecoratorBehaviors(type) {
         // dataclass_transform decorator. If more than one have such a decorator,
         // only the first one will be honored, as per PEP 681.
         functionType =
-            (_a = type.overloads.find((overload) => !!overload.details.decoratorDataClassBehaviors)) !== null && _a !== void 0 ? _a : type.overloads[0];
+            (_a = type.priv.overloads.find((overload) => !!overload.shared.decoratorDataClassBehaviors)) !== null && _a !== void 0 ? _a : type.priv.overloads[0];
     }
     if (!functionType) {
         return undefined;
     }
-    if (functionType.details.decoratorDataClassBehaviors) {
-        return functionType.details.decoratorDataClassBehaviors;
+    if (functionType.shared.decoratorDataClassBehaviors) {
+        return functionType.shared.decoratorDataClassBehaviors;
     }
     // Is this the built-in dataclass? If so, return the default behaviors.
-    if (functionType.details.fullName === 'dataclasses.dataclass') {
+    if (functionType.shared.fullName === 'dataclasses.dataclass') {
         return {
             fieldDescriptorNames: ['dataclasses.field', 'dataclasses.Field'],
         };
@@ -914,15 +845,15 @@ function applyDataClassBehaviorOverrideValue(evaluator, errorNode, classType, ar
             if (argValue !== undefined) {
                 behaviors.frozen = argValue;
             }
-            classType.details.baseClasses.forEach((baseClass) => {
+            classType.shared.baseClasses.forEach((baseClass) => {
                 if ((0, types_1.isInstantiableClass)(baseClass) && types_1.ClassType.isDataClass(baseClass)) {
                     if (types_1.ClassType.isDataClassFrozen(baseClass)) {
                         hasFrozenBaseClass = true;
                     }
-                    else if (!baseClass.details.classDataClassTransform &&
-                        !(baseClass.details.declaredMetaclass &&
-                            (0, types_1.isInstantiableClass)(baseClass.details.declaredMetaclass) &&
-                            !!baseClass.details.declaredMetaclass.details.classDataClassTransform)) {
+                    else if (!baseClass.shared.classDataClassTransform &&
+                        !(baseClass.shared.declaredMetaclass &&
+                            (0, types_1.isInstantiableClass)(baseClass.shared.declaredMetaclass) &&
+                            !!baseClass.shared.declaredMetaclass.shared.classDataClassTransform)) {
                         // If this base class is unfrozen and isn't the class that directly
                         // references the metaclass that provides dataclass-like behaviors,
                         // we'll assume we're deriving from an unfrozen dataclass.
@@ -957,7 +888,7 @@ function applyDataClassBehaviorOverrideValue(evaluator, errorNode, classType, ar
         case 'slots':
             if (argValue === true) {
                 behaviors.generateSlots = true;
-                if (classType.details.localSlotsNames) {
+                if (classType.shared.localSlotsNames) {
                     evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassSlotsOverwrite(), errorNode);
                 }
             }
@@ -979,11 +910,11 @@ function applyDataClassClassBehaviorOverrides(evaluator, errorNode, classType, a
     // The "frozen" behavior is not inherited from the parent class.
     // Instead, it comes from the default.
     behaviors.frozen = behaviors.frozenDefault;
-    classType.details.dataClassBehaviors = behaviors;
+    classType.shared.dataClassBehaviors = behaviors;
     args.forEach((arg) => {
         if (arg.valueExpression && arg.name) {
-            applyDataClassBehaviorOverride(evaluator, arg.name, classType, arg.name.value, arg.valueExpression, behaviors);
-            if (arg.name.value === 'frozen') {
+            applyDataClassBehaviorOverride(evaluator, arg.name, classType, arg.name.d.value, arg.valueExpression, behaviors);
+            if (arg.name.d.value === 'frozen') {
                 sawFrozenArg = true;
             }
         }
@@ -998,7 +929,7 @@ function applyDataClassClassBehaviorOverrides(evaluator, errorNode, classType, a
 exports.applyDataClassClassBehaviorOverrides = applyDataClassClassBehaviorOverrides;
 function applyDataClassDecorator(evaluator, errorNode, classType, defaultBehaviors, callNode) {
     var _a;
-    applyDataClassClassBehaviorOverrides(evaluator, errorNode, classType, (_a = callNode === null || callNode === void 0 ? void 0 : callNode.arguments) !== null && _a !== void 0 ? _a : [], defaultBehaviors);
+    applyDataClassClassBehaviorOverrides(evaluator, errorNode, classType, ((_a = callNode === null || callNode === void 0 ? void 0 : callNode.d.args) !== null && _a !== void 0 ? _a : []).map((arg) => (0, typeUtils_1.convertArgumentNodeToFunctionArgument)(arg)), defaultBehaviors);
 }
 exports.applyDataClassDecorator = applyDataClassDecorator;
 //# sourceMappingURL=dataClasses.js.map