@zzzen/pyright-internal 1.1.254

package/dist/analyzer/dataClasses.js

@@ -0,0 +1,762 @@
+"use strict";
+/*
+ * dataClasses.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * Provides special-case logic for the construction of dataclass
+ * classes and dataclass transform.
+ */
+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.applyDataClassDecorator = exports.applyDataClassDefaultBehaviors = exports.applyDataClassClassBehaviorOverrides = exports.getDataclassDecoratorBehaviors = exports.validateDataClassTransformDecorator = exports.synthesizeDataClassMethods = void 0;
+const debug_1 = require("../common/debug");
+const diagnosticRules_1 = require("../common/diagnosticRules");
+const localize_1 = require("../localization/localize");
+const AnalyzerNodeInfo = __importStar(require("./analyzerNodeInfo"));
+const namedTuples_1 = require("./namedTuples");
+const staticExpressions_1 = require("./staticExpressions");
+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");
+// Validates fields for compatibility with a dataclass and synthesizes
+// an appropriate __new__ and __init__ methods plus __dataclass_fields__
+// and __match_args__ class variables.
+function synthesizeDataClassMethods(evaluator, node, classType, skipSynthesizeInit, hasExistingInitMethod, skipSynthesizeHash) {
+    (0, debug_1.assert)(types_1.ClassType.isDataClass(classType));
+    const classTypeVar = (0, typeUtils_1.synthesizeTypeVarForSelfCls)(classType, /* isClsParam */ true);
+    const newType = types_1.FunctionType.createSynthesizedInstance('__new__', 1 /* ConstructorMethod */);
+    const initType = types_1.FunctionType.createSynthesizedInstance('__init__');
+    types_1.FunctionType.addParameter(newType, {
+        category: 0 /* Simple */,
+        name: 'cls',
+        type: classTypeVar,
+        hasDeclaredType: true,
+    });
+    types_1.FunctionType.addDefaultParameters(newType);
+    newType.details.declaredReturnType = (0, typeUtils_1.convertToInstance)(classTypeVar);
+    const selfParam = {
+        category: 0 /* Simple */,
+        name: 'self',
+        type: (0, typeUtils_1.synthesizeTypeVarForSelfCls)(classType, /* isClsParam */ false),
+        hasDeclaredType: true,
+    };
+    types_1.FunctionType.addParameter(initType, selfParam);
+    initType.details.declaredReturnType = types_1.NoneType.createInstance();
+    // Maintain a list of all dataclass entries (including
+    // those from inherited classes) plus a list of only those
+    // entries added by this class.
+    const localDataClassEntries = [];
+    const fullDataClassEntries = [];
+    const allAncestorsKnown = addInheritedDataClassEntries(classType, fullDataClassEntries);
+    if (!allAncestorsKnown) {
+        // If one or more ancestor classes have an unknown type, we cannot
+        // safely determine the parameter list, so we'll accept any parameters
+        // to avoid a false positive.
+        types_1.FunctionType.addDefaultParameters(initType);
+    }
+    const localEntryTypeEvaluator = [];
+    let sawKeywordOnlySeparator = false;
+    classType.details.fields.forEach((symbol) => {
+        var _a, _b, _c;
+        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 statement = lastDecl.node;
+                while (statement) {
+                    if (statement.nodeType === 3 /* Assignment */) {
+                        break;
+                    }
+                    if (statement.nodeType === 54 /* TypeAnnotation */) {
+                        if (((_a = statement.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 3 /* Assignment */) {
+                            statement = statement.parent;
+                        }
+                        break;
+                    }
+                    statement = statement.parent;
+                }
+                if (!statement) {
+                    return;
+                }
+                let variableNameNode;
+                let aliasName;
+                let variableTypeEvaluator;
+                let hasDefaultValue = false;
+                let isKeywordOnly = types_1.ClassType.isDataClassKeywordOnlyParams(classType) || sawKeywordOnlySeparator;
+                let defaultValueExpression;
+                let includeInInit = true;
+                if (statement.nodeType === 3 /* Assignment */) {
+                    if (statement.leftExpression.nodeType === 54 /* TypeAnnotation */ &&
+                        statement.leftExpression.valueExpression.nodeType === 38 /* Name */) {
+                        variableNameNode = statement.leftExpression.valueExpression;
+                        const assignmentStatement = statement;
+                        variableTypeEvaluator = () => evaluator.getTypeOfAnnotation(assignmentStatement.leftExpression.typeAnnotation, {
+                            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 /* Call */) {
+                        const callType = evaluator.getTypeOfExpression(statement.rightExpression.leftExpression, 2 /* DoNotSpecialize */).type;
+                        if (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) {
+                                const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+                                const value = (0, staticExpressions_1.evaluateStaticBoolExpression)(initArg.valueExpression, fileInfo.executionEnvironment, fileInfo.definedConstants);
+                                if (value === false) {
+                                    includeInInit = false;
+                                }
+                            }
+                            else {
+                                // See if the field constructor has an `init` parameter with
+                                // a default value.
+                                let callTarget;
+                                if ((0, types_1.isFunction)(callType)) {
+                                    callTarget = callType;
+                                }
+                                else if ((0, types_1.isOverloadedFunction)(callType)) {
+                                    callTarget = evaluator.getBestOverloadForArguments(statement.rightExpression, callType, statement.rightExpression.arguments);
+                                }
+                                else if ((0, types_1.isInstantiableClass)(callType)) {
+                                    const initCall = evaluator.getBoundMethod(callType, '__init__');
+                                    if (initCall) {
+                                        if ((0, types_1.isFunction)(initCall)) {
+                                            callTarget = initCall;
+                                        }
+                                        else if ((0, types_1.isOverloadedFunction)(initCall)) {
+                                            callTarget = evaluator.getBestOverloadForArguments(statement.rightExpression, initCall, statement.rightExpression.arguments);
+                                        }
+                                    }
+                                }
+                                if (callTarget) {
+                                    const initParam = callTarget.details.parameters.find((p) => p.name === 'init');
+                                    if (initParam && initParam.defaultValueExpression && initParam.hasDeclaredType) {
+                                        if ((0, types_1.isClass)(initParam.type) &&
+                                            types_1.ClassType.isBuiltIn(initParam.type, 'bool') &&
+                                            (0, typeUtils_1.isLiteralType)(initParam.type)) {
+                                            if (initParam.type.literalValue === false) {
+                                                includeInInit = false;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            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 fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+                                const value = (0, staticExpressions_1.evaluateStaticBoolExpression)(kwOnlyArg.valueExpression, fileInfo.executionEnvironment, fileInfo.definedConstants);
+                                if (value === false) {
+                                    isKeywordOnly = false;
+                                }
+                                else if (value === true) {
+                                    isKeywordOnly = true;
+                                }
+                            }
+                            const defaultArg = statement.rightExpression.arguments.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';
+                            });
+                            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'; });
+                            if (aliasArg) {
+                                const valueType = evaluator.getTypeOfExpression(aliasArg.valueExpression).type;
+                                if ((0, types_1.isClassInstance)(valueType) &&
+                                    types_1.ClassType.isBuiltIn(valueType, 'str') &&
+                                    (0, typeUtils_1.isLiteralType)(valueType)) {
+                                    aliasName = valueType.literalValue;
+                                }
+                            }
+                        }
+                    }
+                }
+                else if (statement.nodeType === 54 /* TypeAnnotation */) {
+                    if (statement.valueExpression.nodeType === 38 /* Name */) {
+                        variableNameNode = statement.valueExpression;
+                        const annotationStatement = statement;
+                        variableTypeEvaluator = () => evaluator.getTypeOfAnnotation(annotationStatement.typeAnnotation, {
+                            isVariableAnnotation: true,
+                            allowFinal: true,
+                            allowClassVar: true,
+                        });
+                        // Is this a KW_ONLY separator introduced in Python 3.10?
+                        if (statement.valueExpression.value === '_') {
+                            const annotatedType = variableTypeEvaluator();
+                            if ((0, types_1.isClassInstance)(annotatedType) && types_1.ClassType.isBuiltIn(annotatedType, 'KW_ONLY')) {
+                                sawKeywordOnlySeparator = true;
+                                variableNameNode = undefined;
+                                variableTypeEvaluator = undefined;
+                            }
+                        }
+                    }
+                }
+                if (variableNameNode && variableTypeEvaluator) {
+                    const variableName = variableNameNode.value;
+                    // Don't include class vars. PEP 557 indicates that they shouldn't
+                    // be considered data class entries.
+                    const variableSymbol = classType.details.fields.get(variableName);
+                    const isFinal = variableSymbol === null || variableSymbol === void 0 ? void 0 : variableSymbol.getDeclarations().some((decl) => decl.type === 1 /* Variable */ && decl.isFinal);
+                    if ((variableSymbol === null || variableSymbol === void 0 ? void 0 : variableSymbol.isClassVar()) && !isFinal) {
+                        // If an ancestor class declared an instance variable but this dataclass
+                        // declares a ClassVar, delete the older one from the full data class entries.
+                        // We exclude final variables here because a Final type annotation is implicitly
+                        // considered a ClassVar by the binder, but dataclass rules are different.
+                        const index = fullDataClassEntries.findIndex((p) => p.name === variableName);
+                        if (index >= 0) {
+                            fullDataClassEntries.splice(index, 1);
+                        }
+                        const dataClassEntry = {
+                            name: variableName,
+                            classType,
+                            alias: aliasName,
+                            isKeywordOnly: false,
+                            hasDefault: hasDefaultValue,
+                            defaultValueExpression,
+                            includeInInit,
+                            type: types_1.UnknownType.create(),
+                            isClassVar: true,
+                        };
+                        localDataClassEntries.push(dataClassEntry);
+                    }
+                    else {
+                        // Create a new data class entry, but defer evaluation of the type until
+                        // we've compiled the full list of data class entries for this class. This
+                        // allows us to handle circular references in types.
+                        const dataClassEntry = {
+                            name: variableName,
+                            classType,
+                            alias: aliasName,
+                            isKeywordOnly,
+                            hasDefault: hasDefaultValue,
+                            defaultValueExpression,
+                            includeInInit,
+                            type: types_1.UnknownType.create(),
+                            isClassVar: false,
+                        };
+                        localEntryTypeEvaluator.push({ entry: dataClassEntry, evaluator: variableTypeEvaluator });
+                        // Add the new entry to the local entry list.
+                        let insertIndex = localDataClassEntries.findIndex((e) => e.name === variableName);
+                        if (insertIndex >= 0) {
+                            localDataClassEntries[insertIndex] = dataClassEntry;
+                        }
+                        else {
+                            localDataClassEntries.push(dataClassEntry);
+                        }
+                        // Add the new entry to the full entry list.
+                        insertIndex = fullDataClassEntries.findIndex((p) => p.name === variableName);
+                        if (insertIndex >= 0) {
+                            const oldEntry = fullDataClassEntries[insertIndex];
+                            // While this isn't documented behavior, it appears that the dataclass implementation
+                            // causes overridden variables to "inherit" default values from parent classes.
+                            if (!dataClassEntry.hasDefault && oldEntry.hasDefault) {
+                                dataClassEntry.hasDefault = true;
+                                dataClassEntry.defaultValueExpression = oldEntry.defaultValueExpression;
+                                hasDefaultValue = true;
+                            }
+                            fullDataClassEntries[insertIndex] = dataClassEntry;
+                        }
+                        else {
+                            fullDataClassEntries.push(dataClassEntry);
+                            insertIndex = fullDataClassEntries.length - 1;
+                        }
+                        // If we've already seen a entry with a default value defined,
+                        // all subsequent entries must also have default values.
+                        if (!isKeywordOnly && includeInInit && !skipSynthesizeInit && !hasDefaultValue) {
+                            const firstDefaultValueIndex = fullDataClassEntries.findIndex((p) => p.hasDefault && p.includeInInit && !p.isKeywordOnly);
+                            if (firstDefaultValueIndex >= 0 && firstDefaultValueIndex < insertIndex) {
+                                evaluator.addError(localize_1.Localizer.Diagnostic.dataClassFieldWithDefault(), variableNameNode);
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                // The symbol had no declared type, so it is (mostly) ignored by dataclasses.
+                // However, if it is assigned a field descriptor, it will result in a
+                // runtime exception.
+                const declarations = symbol.getDeclarations();
+                if (declarations.length === 0) {
+                    return;
+                }
+                const lastDecl = declarations[declarations.length - 1];
+                if (lastDecl.type !== 1 /* Variable */) {
+                    return;
+                }
+                const statement = lastDecl.node.parent;
+                if (!statement || statement.nodeType !== 3 /* Assignment */) {
+                    return;
+                }
+                // 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 /* Call */) {
+                    const callType = evaluator.getTypeOfExpression(statement.rightExpression.leftExpression, 2 /* DoNotSpecialize */).type;
+                    if (isDataclassFieldConstructor(callType, ((_c = classType.details.dataClassBehaviors) === null || _c === void 0 ? void 0 : _c.fieldDescriptorNames) || [])) {
+                        evaluator.addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.dataClassFieldWithoutAnnotation(), statement.rightExpression);
+                    }
+                }
+            }
+        }
+    });
+    classType.details.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
+    // evaluations. This could involve circular type dependencies, so it's
+    // required that the list be complete (even if types are not yet accurate)
+    // before we perform the type evaluations.
+    localEntryTypeEvaluator.forEach((entryEvaluator) => {
+        entryEvaluator.entry.type = entryEvaluator.evaluator();
+    });
+    const symbolTable = classType.details.fields;
+    const keywordOnlyParams = [];
+    if (!skipSynthesizeInit && !hasExistingInitMethod && allAncestorsKnown) {
+        fullDataClassEntries.forEach((entry) => {
+            if (entry.includeInInit) {
+                // If the type refers to Self of the parent class, we need to
+                // transform it to refer to the Self of this subclass.
+                let effectiveType = entry.type;
+                if (entry.classType !== classType && (0, typeUtils_1.requiresSpecialization)(effectiveType)) {
+                    const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(entry.classType));
+                    (0, typeUtils_1.populateTypeVarContextForSelfType)(typeVarContext, entry.classType, classType);
+                    effectiveType = (0, typeUtils_1.applySolvedTypeVars)(effectiveType, typeVarContext);
+                }
+                // Is the field type a descriptor object? If so, we need to extract the corresponding
+                // type of the __init__ method parameter from the __set__ method.
+                effectiveType = transformDescriptorType(evaluator, effectiveType);
+                const functionParam = {
+                    category: 0 /* Simple */,
+                    name: entry.alias || entry.name,
+                    hasDefault: entry.hasDefault,
+                    defaultValueExpression: entry.defaultValueExpression,
+                    type: effectiveType,
+                    hasDeclaredType: true,
+                };
+                if (entry.isKeywordOnly) {
+                    keywordOnlyParams.push(functionParam);
+                }
+                else {
+                    types_1.FunctionType.addParameter(initType, functionParam);
+                }
+            }
+        });
+        if (keywordOnlyParams.length > 0) {
+            types_1.FunctionType.addParameter(initType, {
+                category: 1 /* VarArgList */,
+                type: types_1.AnyType.create(),
+            });
+            keywordOnlyParams.forEach((param) => {
+                types_1.FunctionType.addParameter(initType, param);
+            });
+        }
+        symbolTable.set('__init__', symbol_1.Symbol.createWithType(4 /* ClassMember */, initType));
+        symbolTable.set('__new__', symbol_1.Symbol.createWithType(4 /* ClassMember */, newType));
+    }
+    // Synthesize the __match_args__ class variable if it doesn't exist.
+    const strType = evaluator.getBuiltInType(node, 'str');
+    const tupleClassType = evaluator.getBuiltInType(node, 'tuple');
+    if (tupleClassType &&
+        (0, types_1.isInstantiableClass)(tupleClassType) &&
+        strType &&
+        (0, types_1.isInstantiableClass)(strType) &&
+        !symbolTable.has('__match_args__')) {
+        const matchArgsNames = [];
+        fullDataClassEntries.forEach((entry) => {
+            if (entry.includeInInit && !entry.isKeywordOnly) {
+                // Use the field name, not its alias (if it has one).
+                matchArgsNames.push(entry.name);
+            }
+        });
+        const literalTypes = matchArgsNames.map((name) => {
+            return { type: types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneWithLiteral(strType, name)), isUnbounded: false };
+        });
+        const matchArgsType = types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, literalTypes));
+        symbolTable.set('__match_args__', symbol_1.Symbol.createWithType(4 /* ClassMember */, matchArgsType));
+    }
+    const synthesizeComparisonMethod = (operator, paramType) => {
+        const operatorMethod = types_1.FunctionType.createSynthesizedInstance(operator);
+        types_1.FunctionType.addParameter(operatorMethod, selfParam);
+        types_1.FunctionType.addParameter(operatorMethod, {
+            category: 0 /* Simple */,
+            name: 'other',
+            type: paramType,
+            hasDeclaredType: true,
+        });
+        operatorMethod.details.declaredReturnType = evaluator.getBuiltInObject(node, 'bool');
+        symbolTable.set(operator, symbol_1.Symbol.createWithType(4 /* ClassMember */, operatorMethod));
+    };
+    // Synthesize comparison operators.
+    if (!types_1.ClassType.isSkipSynthesizedDataClassEq(classType)) {
+        synthesizeComparisonMethod('__eq__', evaluator.getBuiltInObject(node, 'object'));
+    }
+    if (types_1.ClassType.isSynthesizedDataclassOrder(classType)) {
+        const objType = types_1.ClassType.cloneAsInstance(classType);
+        ['__lt__', '__le__', '__gt__', '__ge__'].forEach((operator) => {
+            synthesizeComparisonMethod(operator, objType);
+        });
+    }
+    let synthesizeHashFunction = !types_1.ClassType.isSkipSynthesizedDataClassEq(classType) && types_1.ClassType.isFrozenDataClass(classType);
+    const synthesizeHashNone = !types_1.ClassType.isSkipSynthesizedDataClassEq(classType) && !types_1.ClassType.isFrozenDataClass(classType);
+    if (skipSynthesizeHash) {
+        synthesizeHashFunction = false;
+    }
+    // If the user has indicated that a hash function should be generated even if it's unsafe
+    // to do so or there is already a hash function present, override the default logic.
+    if (types_1.ClassType.isSynthesizeDataClassUnsafeHash(classType)) {
+        synthesizeHashFunction = true;
+    }
+    if (synthesizeHashFunction) {
+        const hashMethod = types_1.FunctionType.createSynthesizedInstance('__hash__');
+        types_1.FunctionType.addParameter(hashMethod, selfParam);
+        hashMethod.details.declaredReturnType = evaluator.getBuiltInObject(node, 'int');
+        symbolTable.set('__hash__', symbol_1.Symbol.createWithType(4 /* ClassMember */, hashMethod));
+    }
+    else if (synthesizeHashNone && !skipSynthesizeHash) {
+        symbolTable.set('__hash__', symbol_1.Symbol.createWithType(4 /* ClassMember */, types_1.NoneType.createInstance()));
+    }
+    let dictType = evaluator.getBuiltInType(node, 'dict');
+    if ((0, types_1.isInstantiableClass)(dictType)) {
+        dictType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(dictType, [evaluator.getBuiltInObject(node, 'str'), types_1.AnyType.create()], 
+        /* isTypeArgumentExplicit */ true));
+    }
+    symbolTable.set('__dataclass_fields__', symbol_1.Symbol.createWithType(4 /* ClassMember */, dictType));
+    if (types_1.ClassType.isGeneratedDataClassSlots(classType) && classType.details.localSlotsNames === undefined) {
+        classType.details.localSlotsNames = localDataClassEntries.map((entry) => entry.name);
+    }
+    // If this dataclass derived from a NamedTuple, update the NamedTuple with
+    // the specialized entry types.
+    (0, namedTuples_1.updateNamedTupleBaseClass)(classType, fullDataClassEntries.map((entry) => entry.type), 
+    /* isTypeArgumentExplicit */ true);
+}
+exports.synthesizeDataClassMethods = synthesizeDataClassMethods;
+// If the specified type is a descriptor — in particular, if it implements a
+// __set__ method, this method transforms the type into the input parameter
+// for the set method.
+function transformDescriptorType(evaluator, type) {
+    if (!(0, types_1.isClassInstance)(type)) {
+        return type;
+    }
+    const setMethodInfo = (0, typeUtils_1.lookUpObjectMember)(type, '__set__');
+    if (!setMethodInfo) {
+        return type;
+    }
+    const setMethodType = evaluator.getTypeOfMember(setMethodInfo);
+    if (!(0, types_1.isFunction)(setMethodType)) {
+        return type;
+    }
+    const boundSetMethod = evaluator.bindFunctionToClassOrObject(type, setMethodType);
+    if (!boundSetMethod || !(0, types_1.isFunction)(boundSetMethod) || boundSetMethod.details.parameters.length < 2) {
+        return type;
+    }
+    // The value parameter for a bound __set__ method is parameter index 1.
+    return types_1.FunctionType.getEffectiveParameterType(boundSetMethod, 1);
+}
+// Builds a sorted list of dataclass entries that are inherited by
+// the specified class. These entries must be unique and in reverse-MRO
+// order. Returns true if all of the class types in the hierarchy are
+// known, false if one or more are unknown.
+function addInheritedDataClassEntries(classType, entries) {
+    let allAncestorsAreKnown = true;
+    for (let i = classType.details.mro.length - 1; i >= 0; i--) {
+        const mroClass = classType.details.mro[i];
+        if ((0, types_1.isInstantiableClass)(mroClass)) {
+            const typeVarContext = (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(mroClass, /* makeConcrete */ false);
+            const dataClassEntries = types_1.ClassType.getDataClassEntries(mroClass);
+            // Add the entries to the end of the list, replacing same-named
+            // entries if found.
+            dataClassEntries.forEach((entry) => {
+                const existingIndex = entries.findIndex((e) => e.name === entry.name);
+                // If the type from the parent class is generic, we need to convert
+                // to the type parameter namespace of child class.
+                const updatedEntry = { ...entry };
+                updatedEntry.type = (0, typeUtils_1.applySolvedTypeVars)(updatedEntry.type, typeVarContext);
+                if (entry.isClassVar) {
+                    // If this entry is a class variable, it overrides an existing
+                    // instance variable, so delete it.
+                    if (existingIndex >= 0) {
+                        entries.splice(existingIndex, 1);
+                    }
+                }
+                else if (existingIndex >= 0) {
+                    entries[existingIndex] = updatedEntry;
+                }
+                else {
+                    entries.push(updatedEntry);
+                }
+            });
+        }
+        else {
+            allAncestorsAreKnown = false;
+        }
+    }
+    return allAncestorsAreKnown;
+}
+function isDataclassFieldConstructor(type, fieldDescriptorNames) {
+    let callName;
+    if ((0, types_1.isFunction)(type)) {
+        callName = type.details.fullName;
+    }
+    else if ((0, types_1.isOverloadedFunction)(type)) {
+        callName = type.overloads[0].details.fullName;
+    }
+    else if ((0, types_1.isInstantiableClass)(type)) {
+        callName = type.details.fullName;
+    }
+    if (!callName) {
+        return false;
+    }
+    return fieldDescriptorNames.some((name) => name === callName);
+}
+function validateDataClassTransformDecorator(evaluator, node) {
+    const behaviors = {
+        keywordOnlyParams: false,
+        generateEq: true,
+        generateOrder: false,
+        fieldDescriptorNames: [],
+    };
+    const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+    // Parse the arguments to the call.
+    node.arguments.forEach((arg) => {
+        if (!arg.name || arg.argumentCategory !== 0 /* Simple */) {
+            evaluator.addError(localize_1.Localizer.Diagnostic.dataClassTransformPositionalParam(), arg);
+            return;
+        }
+        switch (arg.name.value) {
+            case 'kw_only_default': {
+                const value = (0, staticExpressions_1.evaluateStaticBoolExpression)(arg.valueExpression, fileInfo.executionEnvironment, fileInfo.definedConstants);
+                if (value === undefined) {
+                    evaluator.addError(localize_1.Localizer.Diagnostic.dataClassTransformExpectedBoolLiteral(), arg.valueExpression);
+                    return;
+                }
+                behaviors.keywordOnlyParams = value;
+                break;
+            }
+            case 'eq_default': {
+                const value = (0, staticExpressions_1.evaluateStaticBoolExpression)(arg.valueExpression, fileInfo.executionEnvironment, fileInfo.definedConstants);
+                if (value === undefined) {
+                    evaluator.addError(localize_1.Localizer.Diagnostic.dataClassTransformExpectedBoolLiteral(), arg.valueExpression);
+                    return;
+                }
+                behaviors.generateEq = value;
+                break;
+            }
+            case 'order_default': {
+                const value = (0, staticExpressions_1.evaluateStaticBoolExpression)(arg.valueExpression, fileInfo.executionEnvironment, fileInfo.definedConstants);
+                if (value === undefined) {
+                    evaluator.addError(localize_1.Localizer.Diagnostic.dataClassTransformExpectedBoolLiteral(), arg.valueExpression);
+                    return;
+                }
+                behaviors.generateOrder = value;
+                break;
+            }
+            // Earlier versions of the dataclass_transform spec used the name "field_descriptors"
+            // rather than "field_specifiers". The older name is now deprecated but still supported
+            // for the time being because some libraries shipped with the older __dataclass_transform__
+            // form that supported this older parameter name.
+            case 'field_descriptors':
+            case 'field_specifiers': {
+                const valueType = evaluator.getTypeOfExpression(arg.valueExpression).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) &&
+                        !(0, types_1.isFunction)(entry.type) &&
+                        !(0, types_1.isOverloadedFunction)(entry.type))) {
+                    evaluator.addError(localize_1.Localizer.Diagnostic.dataClassTransformFieldSpecifier().format({
+                        type: evaluator.printType(valueType),
+                    }), arg.valueExpression);
+                    return;
+                }
+                if (!behaviors.fieldDescriptorNames) {
+                    behaviors.fieldDescriptorNames = [];
+                }
+                valueType.tupleTypeArguments.forEach((arg) => {
+                    if ((0, types_1.isInstantiableClass)(arg.type) || (0, types_1.isFunction)(arg.type)) {
+                        behaviors.fieldDescriptorNames.push(arg.type.details.fullName);
+                    }
+                    else if ((0, types_1.isOverloadedFunction)(arg.type)) {
+                        behaviors.fieldDescriptorNames.push(arg.type.overloads[0].details.fullName);
+                    }
+                });
+                break;
+            }
+            default:
+                evaluator.addError(localize_1.Localizer.Diagnostic.dataClassTransformUnknownArgument().format({ name: arg.name.value }), arg.valueExpression);
+                break;
+        }
+    });
+    return behaviors;
+}
+exports.validateDataClassTransformDecorator = validateDataClassTransformDecorator;
+function getDataclassDecoratorBehaviors(type) {
+    var _a;
+    let functionType;
+    if ((0, types_1.isFunction)(type)) {
+        functionType = type;
+    }
+    else if ((0, types_1.isOverloadedFunction)(type)) {
+        // Find the first overload or implementation that contains a
+        // 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];
+    }
+    if (!functionType) {
+        return undefined;
+    }
+    if (functionType.details.decoratorDataClassBehaviors) {
+        return functionType.details.decoratorDataClassBehaviors;
+    }
+    // Is this the built-in dataclass? If so, return the default behaviors.
+    if (functionType.details.fullName === 'dataclasses.dataclass') {
+        return {
+            keywordOnlyParams: false,
+            generateEq: true,
+            generateOrder: false,
+            fieldDescriptorNames: ['dataclasses.field', 'dataclasses.Field'],
+        };
+    }
+    return undefined;
+}
+exports.getDataclassDecoratorBehaviors = getDataclassDecoratorBehaviors;
+function applyDataClassBehaviorOverride(evaluator, errorNode, classType, argName, argValue) {
+    const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
+    const value = (0, staticExpressions_1.evaluateStaticBoolExpression)(argValue, fileInfo.executionEnvironment, fileInfo.definedConstants);
+    switch (argName) {
+        case 'order':
+            if (value === true) {
+                classType.details.flags |= 64 /* SynthesizedDataClassOrder */;
+            }
+            else if (value === false) {
+                classType.details.flags &= ~64 /* SynthesizedDataClassOrder */;
+            }
+            break;
+        case 'kw_only':
+            if (value === false) {
+                classType.details.flags &= ~2097152 /* DataClassKeywordOnlyParams */;
+            }
+            else if (value === true) {
+                classType.details.flags |= 2097152 /* DataClassKeywordOnlyParams */;
+            }
+            break;
+        case 'frozen': {
+            let hasUnfrozenBaseClass = false;
+            let hasFrozenBaseClass = false;
+            classType.details.baseClasses.forEach((baseClass) => {
+                if ((0, types_1.isInstantiableClass)(baseClass) && types_1.ClassType.isDataClass(baseClass)) {
+                    if (types_1.ClassType.isFrozenDataClass(baseClass)) {
+                        hasFrozenBaseClass = true;
+                    }
+                    else if (!baseClass.details.classDataClassTransform &&
+                        !(baseClass.details.declaredMetaclass &&
+                            (0, types_1.isInstantiableClass)(baseClass.details.declaredMetaclass) &&
+                            !!baseClass.details.declaredMetaclass.details.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.
+                        hasUnfrozenBaseClass = true;
+                    }
+                }
+            });
+            if (value === true || hasFrozenBaseClass) {
+                classType.details.flags |= 8 /* FrozenDataClass */;
+                // A frozen dataclass cannot derive from a non-frozen dataclass.
+                if (hasUnfrozenBaseClass) {
+                    evaluator.addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.dataClassBaseClassNotFrozen(), errorNode);
+                }
+            }
+            break;
+        }
+        case 'init':
+            if (value === false) {
+                classType.details.flags |= 16 /* SkipSynthesizedDataClassInit */;
+            }
+            else if (value === true) {
+                classType.details.flags &= ~16 /* SkipSynthesizedDataClassInit */;
+            }
+            break;
+        case 'eq':
+            if (value === false) {
+                classType.details.flags |= 32 /* SkipSynthesizedDataClassEq */;
+            }
+            else if (value === true) {
+                classType.details.flags &= ~32 /* SkipSynthesizedDataClassEq */;
+            }
+            break;
+        case 'slots':
+            if (value === true) {
+                classType.details.flags |= 33554432 /* GenerateDataClassSlots */;
+                if (classType.details.localSlotsNames) {
+                    evaluator.addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.dataClassSlotsOverwrite(), errorNode);
+                }
+            }
+            else if (value === false) {
+                classType.details.flags &= ~33554432 /* GenerateDataClassSlots */;
+            }
+            break;
+        case 'hash':
+        case 'unsafe_hash':
+            if (value === true) {
+                classType.details.flags |= 67108864 /* SynthesizeDataClassUnsafeHash */;
+            }
+            break;
+    }
+}
+function applyDataClassClassBehaviorOverrides(evaluator, classType, args) {
+    args.forEach((arg) => {
+        if (arg.valueExpression && arg.name) {
+            applyDataClassBehaviorOverride(evaluator, arg.name, classType, arg.name.value, arg.valueExpression);
+        }
+    });
+}
+exports.applyDataClassClassBehaviorOverrides = applyDataClassClassBehaviorOverrides;
+function applyDataClassDefaultBehaviors(classType, defaultBehaviors) {
+    classType.details.dataClassBehaviors = defaultBehaviors;
+    classType.details.flags |= 4 /* DataClass */;
+    if (defaultBehaviors.keywordOnlyParams) {
+        classType.details.flags |= 2097152 /* DataClassKeywordOnlyParams */;
+    }
+    if (!defaultBehaviors.generateEq) {
+        classType.details.flags |= 32 /* SkipSynthesizedDataClassEq */;
+    }
+    if (defaultBehaviors.generateOrder) {
+        classType.details.flags |= 64 /* SynthesizedDataClassOrder */;
+    }
+}
+exports.applyDataClassDefaultBehaviors = applyDataClassDefaultBehaviors;
+function applyDataClassDecorator(evaluator, classType, defaultBehaviors, callNode) {
+    applyDataClassDefaultBehaviors(classType, defaultBehaviors);
+    if (callNode === null || callNode === void 0 ? void 0 : callNode.arguments) {
+        applyDataClassClassBehaviorOverrides(evaluator, classType, callNode.arguments);
+    }
+}
+exports.applyDataClassDecorator = applyDataClassDecorator;
+//# sourceMappingURL=dataClasses.js.map