@zzzen/pyright-internal 1.1.255 → 1.2.0-beta

package/src/analyzer/dataClasses.ts

@@ -1,999 +0,0 @@
-/*
- * 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.
- */
-
-import { assert } from '../common/debug';
-import { DiagnosticRule } from '../common/diagnosticRules';
-import { Localizer } from '../localization/localize';
-import {
-    ArgumentCategory,
-    CallNode,
-    ClassNode,
-    ExpressionNode,
-    NameNode,
-    ParameterCategory,
-    ParseNode,
-    ParseNodeType,
-    TypeAnnotationNode,
-} from '../parser/parseNodes';
-import * as AnalyzerNodeInfo from './analyzerNodeInfo';
-import { DeclarationType } from './declaration';
-import { updateNamedTupleBaseClass } from './namedTuples';
-import { evaluateStaticBoolExpression } from './staticExpressions';
-import { Symbol, SymbolFlags } from './symbol';
-import { getLastTypedDeclaredForSymbol } from './symbolUtils';
-import { EvaluatorFlags, FunctionArgument, TypeEvaluator } from './typeEvaluatorTypes';
-import {
-    AnyType,
-    ClassType,
-    ClassTypeFlags,
-    DataClassBehaviors,
-    DataClassEntry,
-    FunctionParameter,
-    FunctionType,
-    FunctionTypeFlags,
-    isClass,
-    isClassInstance,
-    isFunction,
-    isInstantiableClass,
-    isOverloadedFunction,
-    NoneType,
-    TupleTypeArgument,
-    Type,
-    UnknownType,
-} from './types';
-import {
-    applySolvedTypeVars,
-    buildTypeVarContextFromSpecializedClass,
-    convertToInstance,
-    getTypeVarScopeId,
-    isLiteralType,
-    lookUpObjectMember,
-    populateTypeVarContextForSelfType,
-    requiresSpecialization,
-    specializeTupleClass,
-    synthesizeTypeVarForSelfCls,
-} from './typeUtils';
-import { TypeVarContext } from './typeVarContext';
-
-// Validates fields for compatibility with a dataclass and synthesizes
-// an appropriate __new__ and __init__ methods plus __dataclass_fields__
-// and __match_args__ class variables.
-export function synthesizeDataClassMethods(
-    evaluator: TypeEvaluator,
-    node: ClassNode,
-    classType: ClassType,
-    skipSynthesizeInit: boolean,
-    hasExistingInitMethod: boolean,
-    skipSynthesizeHash: boolean
-) {
-    assert(ClassType.isDataClass(classType));
-
-    const classTypeVar = synthesizeTypeVarForSelfCls(classType, /* isClsParam */ true);
-    const newType = FunctionType.createSynthesizedInstance('__new__', FunctionTypeFlags.ConstructorMethod);
-    const initType = FunctionType.createSynthesizedInstance('__init__');
-
-    FunctionType.addParameter(newType, {
-        category: ParameterCategory.Simple,
-        name: 'cls',
-        type: classTypeVar,
-        hasDeclaredType: true,
-    });
-    FunctionType.addDefaultParameters(newType);
-    newType.details.declaredReturnType = convertToInstance(classTypeVar);
-
-    const selfParam: FunctionParameter = {
-        category: ParameterCategory.Simple,
-        name: 'self',
-        type: synthesizeTypeVarForSelfCls(classType, /* isClsParam */ false),
-        hasDeclaredType: true,
-    };
-    FunctionType.addParameter(initType, selfParam);
-    initType.details.declaredReturnType = 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: DataClassEntry[] = [];
-    const fullDataClassEntries: DataClassEntry[] = [];
-    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.
-        FunctionType.addDefaultParameters(initType);
-    }
-
-    // Maintain a list of "type evaluators".
-    type EntryTypeEvaluator = () => Type;
-    const localEntryTypeEvaluator: { entry: DataClassEntry; evaluator: EntryTypeEvaluator }[] = [];
-    let sawKeywordOnlySeparator = false;
-
-    classType.details.fields.forEach((symbol) => {
-        if (!symbol.isIgnoredForProtocolMatch()) {
-            // Only variables (not functions, classes, etc.) are considered.
-            const lastDecl = getLastTypedDeclaredForSymbol(symbol);
-            if (lastDecl && lastDecl.type === DeclarationType.Variable) {
-                let statement: ParseNode | undefined = lastDecl.node;
-
-                while (statement) {
-                    if (statement.nodeType === ParseNodeType.Assignment) {
-                        break;
-                    }
-
-                    if (statement.nodeType === ParseNodeType.TypeAnnotation) {
-                        if (statement.parent?.nodeType === ParseNodeType.Assignment) {
-                            statement = statement.parent;
-                        }
-                        break;
-                    }
-
-                    statement = statement.parent;
-                }
-
-                if (!statement) {
-                    return;
-                }
-
-                let variableNameNode: NameNode | undefined;
-                let aliasName: string | undefined;
-                let variableTypeEvaluator: EntryTypeEvaluator | undefined;
-                let hasDefaultValue = false;
-                let isKeywordOnly = ClassType.isDataClassKeywordOnlyParams(classType) || sawKeywordOnlySeparator;
-                let defaultValueExpression: ExpressionNode | undefined;
-                let includeInInit = true;
-
-                if (statement.nodeType === ParseNodeType.Assignment) {
-                    if (
-                        statement.leftExpression.nodeType === ParseNodeType.TypeAnnotation &&
-                        statement.leftExpression.valueExpression.nodeType === ParseNodeType.Name
-                    ) {
-                        variableNameNode = statement.leftExpression.valueExpression;
-                        const assignmentStatement = statement;
-                        variableTypeEvaluator = () =>
-                            evaluator.getTypeOfAnnotation(
-                                (assignmentStatement.leftExpression as TypeAnnotationNode).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 === ParseNodeType.Call) {
-                        const callType = evaluator.getTypeOfExpression(
-                            statement.rightExpression.leftExpression,
-                            EvaluatorFlags.DoNotSpecialize
-                        ).type;
-                        if (
-                            isDataclassFieldConstructor(
-                                callType,
-                                classType.details.dataClassBehaviors?.fieldDescriptorNames || []
-                            )
-                        ) {
-                            const initArg = statement.rightExpression.arguments.find(
-                                (arg) => arg.name?.value === 'init'
-                            );
-                            if (initArg && initArg.valueExpression) {
-                                const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-                                const value = 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: FunctionType | undefined;
-                                if (isFunction(callType)) {
-                                    callTarget = callType;
-                                } else if (isOverloadedFunction(callType)) {
-                                    callTarget = evaluator.getBestOverloadForArguments(
-                                        statement.rightExpression,
-                                        callType,
-                                        statement.rightExpression.arguments
-                                    );
-                                } else if (isInstantiableClass(callType)) {
-                                    const initCall = evaluator.getBoundMethod(callType, '__init__');
-                                    if (initCall) {
-                                        if (isFunction(initCall)) {
-                                            callTarget = initCall;
-                                        } else if (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 (
-                                            isClass(initParam.type) &&
-                                            ClassType.isBuiltIn(initParam.type, 'bool') &&
-                                            isLiteralType(initParam.type)
-                                        ) {
-                                            if (initParam.type.literalValue === false) {
-                                                includeInInit = false;
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-
-                            const kwOnlyArg = statement.rightExpression.arguments.find(
-                                (arg) => arg.name?.value === 'kw_only'
-                            );
-                            if (kwOnlyArg && kwOnlyArg.valueExpression) {
-                                const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-                                const value = 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) =>
-                                    arg.name?.value === 'default' ||
-                                    arg.name?.value === 'default_factory' ||
-                                    arg.name?.value === 'factory'
-                            );
-
-                            hasDefaultValue = !!defaultArg;
-                            if (defaultArg?.valueExpression) {
-                                defaultValueExpression = defaultArg.valueExpression;
-                            }
-
-                            const aliasArg = statement.rightExpression.arguments.find(
-                                (arg) => arg.name?.value === 'alias'
-                            );
-                            if (aliasArg) {
-                                const valueType = evaluator.getTypeOfExpression(aliasArg.valueExpression).type;
-                                if (
-                                    isClassInstance(valueType) &&
-                                    ClassType.isBuiltIn(valueType, 'str') &&
-                                    isLiteralType(valueType)
-                                ) {
-                                    aliasName = valueType.literalValue as string;
-                                }
-                            }
-                        }
-                    }
-                } else if (statement.nodeType === ParseNodeType.TypeAnnotation) {
-                    if (statement.valueExpression.nodeType === ParseNodeType.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 (isClassInstance(annotatedType) && 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
-                        ?.getDeclarations()
-                        .some((decl) => decl.type === DeclarationType.Variable && decl.isFinal);
-
-                    if (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: DataClassEntry = {
-                            name: variableName,
-                            classType,
-                            alias: aliasName,
-                            isKeywordOnly: false,
-                            hasDefault: hasDefaultValue,
-                            defaultValueExpression,
-                            includeInInit,
-                            type: 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: DataClassEntry = {
-                            name: variableName,
-                            classType,
-                            alias: aliasName,
-                            isKeywordOnly,
-                            hasDefault: hasDefaultValue,
-                            defaultValueExpression,
-                            includeInInit,
-                            type: 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(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 !== DeclarationType.Variable) {
-                    return;
-                }
-
-                const statement = lastDecl.node.parent;
-                if (!statement || statement.nodeType !== ParseNodeType.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 === ParseNodeType.Call) {
-                    const callType = evaluator.getTypeOfExpression(
-                        statement.rightExpression.leftExpression,
-                        EvaluatorFlags.DoNotSpecialize
-                    ).type;
-
-                    if (
-                        isDataclassFieldConstructor(
-                            callType,
-                            classType.details.dataClassBehaviors?.fieldDescriptorNames || []
-                        )
-                    ) {
-                        evaluator.addDiagnostic(
-                            AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues,
-                            DiagnosticRule.reportGeneralTypeIssues,
-                            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: FunctionParameter[] = [];
-
-    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 && requiresSpecialization(effectiveType)) {
-                    const typeVarContext = new TypeVarContext(getTypeVarScopeId(entry.classType));
-                    populateTypeVarContextForSelfType(typeVarContext, entry.classType, classType);
-                    effectiveType = 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: FunctionParameter = {
-                    category: ParameterCategory.Simple,
-                    name: entry.alias || entry.name,
-                    hasDefault: entry.hasDefault,
-                    defaultValueExpression: entry.defaultValueExpression,
-                    type: effectiveType,
-                    hasDeclaredType: true,
-                };
-
-                if (entry.isKeywordOnly) {
-                    keywordOnlyParams.push(functionParam);
-                } else {
-                    FunctionType.addParameter(initType, functionParam);
-                }
-            }
-        });
-
-        if (keywordOnlyParams.length > 0) {
-            FunctionType.addParameter(initType, {
-                category: ParameterCategory.VarArgList,
-                type: AnyType.create(),
-            });
-            keywordOnlyParams.forEach((param) => {
-                FunctionType.addParameter(initType, param);
-            });
-        }
-
-        symbolTable.set('__init__', Symbol.createWithType(SymbolFlags.ClassMember, initType));
-        symbolTable.set('__new__', Symbol.createWithType(SymbolFlags.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 &&
-        isInstantiableClass(tupleClassType) &&
-        strType &&
-        isInstantiableClass(strType) &&
-        !symbolTable.has('__match_args__')
-    ) {
-        const matchArgsNames: string[] = [];
-        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: TupleTypeArgument[] = matchArgsNames.map((name) => {
-            return { type: ClassType.cloneAsInstance(ClassType.cloneWithLiteral(strType, name)), isUnbounded: false };
-        });
-        const matchArgsType = ClassType.cloneAsInstance(specializeTupleClass(tupleClassType, literalTypes));
-        symbolTable.set('__match_args__', Symbol.createWithType(SymbolFlags.ClassMember, matchArgsType));
-    }
-
-    const synthesizeComparisonMethod = (operator: string, paramType: Type) => {
-        const operatorMethod = FunctionType.createSynthesizedInstance(operator);
-        FunctionType.addParameter(operatorMethod, selfParam);
-        FunctionType.addParameter(operatorMethod, {
-            category: ParameterCategory.Simple,
-            name: 'other',
-            type: paramType,
-            hasDeclaredType: true,
-        });
-        operatorMethod.details.declaredReturnType = evaluator.getBuiltInObject(node, 'bool');
-        symbolTable.set(operator, Symbol.createWithType(SymbolFlags.ClassMember, operatorMethod));
-    };
-
-    // Synthesize comparison operators.
-    if (!ClassType.isSkipSynthesizedDataClassEq(classType)) {
-        synthesizeComparisonMethod('__eq__', evaluator.getBuiltInObject(node, 'object'));
-    }
-
-    if (ClassType.isSynthesizedDataclassOrder(classType)) {
-        const objType = ClassType.cloneAsInstance(classType);
-        ['__lt__', '__le__', '__gt__', '__ge__'].forEach((operator) => {
-            synthesizeComparisonMethod(operator, objType);
-        });
-    }
-
-    let synthesizeHashFunction =
-        !ClassType.isSkipSynthesizedDataClassEq(classType) && ClassType.isFrozenDataClass(classType);
-    const synthesizeHashNone =
-        !ClassType.isSkipSynthesizedDataClassEq(classType) && !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 (ClassType.isSynthesizeDataClassUnsafeHash(classType)) {
-        synthesizeHashFunction = true;
-    }
-
-    if (synthesizeHashFunction) {
-        const hashMethod = FunctionType.createSynthesizedInstance('__hash__');
-        FunctionType.addParameter(hashMethod, selfParam);
-        hashMethod.details.declaredReturnType = evaluator.getBuiltInObject(node, 'int');
-        symbolTable.set('__hash__', Symbol.createWithType(SymbolFlags.ClassMember, hashMethod));
-    } else if (synthesizeHashNone && !skipSynthesizeHash) {
-        symbolTable.set('__hash__', Symbol.createWithType(SymbolFlags.ClassMember, NoneType.createInstance()));
-    }
-
-    let dictType = evaluator.getBuiltInType(node, 'dict');
-    if (isInstantiableClass(dictType)) {
-        dictType = ClassType.cloneAsInstance(
-            ClassType.cloneForSpecialization(
-                dictType,
-                [evaluator.getBuiltInObject(node, 'str'), AnyType.create()],
-                /* isTypeArgumentExplicit */ true
-            )
-        );
-    }
-    symbolTable.set('__dataclass_fields__', Symbol.createWithType(SymbolFlags.ClassMember, dictType));
-
-    if (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.
-    updateNamedTupleBaseClass(
-        classType,
-        fullDataClassEntries.map((entry) => entry.type),
-        /* isTypeArgumentExplicit */ true
-    );
-}
-
-// 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: TypeEvaluator, type: Type): Type {
-    if (!isClassInstance(type)) {
-        return type;
-    }
-
-    const setMethodInfo = lookUpObjectMember(type, '__set__');
-    if (!setMethodInfo) {
-        return type;
-    }
-
-    const setMethodType = evaluator.getTypeOfMember(setMethodInfo);
-    if (!isFunction(setMethodType)) {
-        return type;
-    }
-
-    const boundSetMethod = evaluator.bindFunctionToClassOrObject(type, setMethodType);
-    if (!boundSetMethod || !isFunction(boundSetMethod) || boundSetMethod.details.parameters.length < 2) {
-        return type;
-    }
-
-    // The value parameter for a bound __set__ method is parameter index 1.
-    return 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: ClassType, entries: DataClassEntry[]) {
-    let allAncestorsAreKnown = true;
-
-    for (let i = classType.details.mro.length - 1; i >= 0; i--) {
-        const mroClass = classType.details.mro[i];
-
-        if (isInstantiableClass(mroClass)) {
-            const typeVarContext = buildTypeVarContextFromSpecializedClass(mroClass, /* makeConcrete */ false);
-            const dataClassEntries = 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 = 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: Type, fieldDescriptorNames: string[]) {
-    let callName: string | undefined;
-
-    if (isFunction(type)) {
-        callName = type.details.fullName;
-    } else if (isOverloadedFunction(type)) {
-        callName = type.overloads[0].details.fullName;
-    } else if (isInstantiableClass(type)) {
-        callName = type.details.fullName;
-    }
-
-    if (!callName) {
-        return false;
-    }
-
-    return fieldDescriptorNames.some((name) => name === callName);
-}
-
-export function validateDataClassTransformDecorator(
-    evaluator: TypeEvaluator,
-    node: CallNode
-): DataClassBehaviors | undefined {
-    const behaviors: DataClassBehaviors = {
-        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 !== ArgumentCategory.Simple) {
-            evaluator.addError(Localizer.Diagnostic.dataClassTransformPositionalParam(), arg);
-            return;
-        }
-
-        switch (arg.name.value) {
-            case 'kw_only_default': {
-                const value = evaluateStaticBoolExpression(
-                    arg.valueExpression,
-                    fileInfo.executionEnvironment,
-                    fileInfo.definedConstants
-                );
-                if (value === undefined) {
-                    evaluator.addError(
-                        Localizer.Diagnostic.dataClassTransformExpectedBoolLiteral(),
-                        arg.valueExpression
-                    );
-                    return;
-                }
-
-                behaviors.keywordOnlyParams = value;
-                break;
-            }
-
-            case 'eq_default': {
-                const value = evaluateStaticBoolExpression(
-                    arg.valueExpression,
-                    fileInfo.executionEnvironment,
-                    fileInfo.definedConstants
-                );
-                if (value === undefined) {
-                    evaluator.addError(
-                        Localizer.Diagnostic.dataClassTransformExpectedBoolLiteral(),
-                        arg.valueExpression
-                    );
-                    return;
-                }
-
-                behaviors.generateEq = value;
-                break;
-            }
-
-            case 'order_default': {
-                const value = evaluateStaticBoolExpression(
-                    arg.valueExpression,
-                    fileInfo.executionEnvironment,
-                    fileInfo.definedConstants
-                );
-                if (value === undefined) {
-                    evaluator.addError(
-                        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 (
-                    !isClassInstance(valueType) ||
-                    !ClassType.isBuiltIn(valueType, 'tuple') ||
-                    !valueType.tupleTypeArguments ||
-                    valueType.tupleTypeArguments.some(
-                        (entry) =>
-                            !isInstantiableClass(entry.type) &&
-                            !isFunction(entry.type) &&
-                            !isOverloadedFunction(entry.type)
-                    )
-                ) {
-                    evaluator.addError(
-                        Localizer.Diagnostic.dataClassTransformFieldSpecifier().format({
-                            type: evaluator.printType(valueType),
-                        }),
-                        arg.valueExpression
-                    );
-                    return;
-                }
-
-                if (!behaviors.fieldDescriptorNames) {
-                    behaviors.fieldDescriptorNames = [];
-                }
-                valueType.tupleTypeArguments.forEach((arg) => {
-                    if (isInstantiableClass(arg.type) || isFunction(arg.type)) {
-                        behaviors.fieldDescriptorNames.push(arg.type.details.fullName);
-                    } else if (isOverloadedFunction(arg.type)) {
-                        behaviors.fieldDescriptorNames.push(arg.type.overloads[0].details.fullName);
-                    }
-                });
-                break;
-            }
-
-            default:
-                evaluator.addError(
-                    Localizer.Diagnostic.dataClassTransformUnknownArgument().format({ name: arg.name.value }),
-                    arg.valueExpression
-                );
-                break;
-        }
-    });
-
-    return behaviors;
-}
-
-export function getDataclassDecoratorBehaviors(type: Type): DataClassBehaviors | undefined {
-    let functionType: FunctionType | undefined;
-    if (isFunction(type)) {
-        functionType = type;
-    } else if (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 =
-            type.overloads.find((overload) => !!overload.details.decoratorDataClassBehaviors) ?? 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;
-}
-
-function applyDataClassBehaviorOverride(
-    evaluator: TypeEvaluator,
-    errorNode: ParseNode,
-    classType: ClassType,
-    argName: string,
-    argValue: ExpressionNode
-) {
-    const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
-    const value = evaluateStaticBoolExpression(argValue, fileInfo.executionEnvironment, fileInfo.definedConstants);
-
-    switch (argName) {
-        case 'order':
-            if (value === true) {
-                classType.details.flags |= ClassTypeFlags.SynthesizedDataClassOrder;
-            } else if (value === false) {
-                classType.details.flags &= ~ClassTypeFlags.SynthesizedDataClassOrder;
-            }
-            break;
-
-        case 'kw_only':
-            if (value === false) {
-                classType.details.flags &= ~ClassTypeFlags.DataClassKeywordOnlyParams;
-            } else if (value === true) {
-                classType.details.flags |= ClassTypeFlags.DataClassKeywordOnlyParams;
-            }
-            break;
-
-        case 'frozen': {
-            let hasUnfrozenBaseClass = false;
-            let hasFrozenBaseClass = false;
-
-            classType.details.baseClasses.forEach((baseClass) => {
-                if (isInstantiableClass(baseClass) && ClassType.isDataClass(baseClass)) {
-                    if (ClassType.isFrozenDataClass(baseClass)) {
-                        hasFrozenBaseClass = true;
-                    } else if (
-                        !baseClass.details.classDataClassTransform &&
-                        !(
-                            baseClass.details.declaredMetaclass &&
-                            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 |= ClassTypeFlags.FrozenDataClass;
-
-                // A frozen dataclass cannot derive from a non-frozen dataclass.
-                if (hasUnfrozenBaseClass) {
-                    evaluator.addDiagnostic(
-                        fileInfo.diagnosticRuleSet.reportGeneralTypeIssues,
-                        DiagnosticRule.reportGeneralTypeIssues,
-                        Localizer.Diagnostic.dataClassBaseClassNotFrozen(),
-                        errorNode
-                    );
-                }
-            }
-            break;
-        }
-
-        case 'init':
-            if (value === false) {
-                classType.details.flags |= ClassTypeFlags.SkipSynthesizedDataClassInit;
-            } else if (value === true) {
-                classType.details.flags &= ~ClassTypeFlags.SkipSynthesizedDataClassInit;
-            }
-            break;
-
-        case 'eq':
-            if (value === false) {
-                classType.details.flags |= ClassTypeFlags.SkipSynthesizedDataClassEq;
-            } else if (value === true) {
-                classType.details.flags &= ~ClassTypeFlags.SkipSynthesizedDataClassEq;
-            }
-            break;
-
-        case 'slots':
-            if (value === true) {
-                classType.details.flags |= ClassTypeFlags.GenerateDataClassSlots;
-
-                if (classType.details.localSlotsNames) {
-                    evaluator.addDiagnostic(
-                        fileInfo.diagnosticRuleSet.reportGeneralTypeIssues,
-                        DiagnosticRule.reportGeneralTypeIssues,
-                        Localizer.Diagnostic.dataClassSlotsOverwrite(),
-                        errorNode
-                    );
-                }
-            } else if (value === false) {
-                classType.details.flags &= ~ClassTypeFlags.GenerateDataClassSlots;
-            }
-            break;
-
-        case 'hash':
-        case 'unsafe_hash':
-            if (value === true) {
-                classType.details.flags |= ClassTypeFlags.SynthesizeDataClassUnsafeHash;
-            }
-            break;
-    }
-}
-
-export function applyDataClassClassBehaviorOverrides(
-    evaluator: TypeEvaluator,
-    classType: ClassType,
-    args: FunctionArgument[]
-) {
-    args.forEach((arg) => {
-        if (arg.valueExpression && arg.name) {
-            applyDataClassBehaviorOverride(evaluator, arg.name, classType, arg.name.value, arg.valueExpression);
-        }
-    });
-}
-
-export function applyDataClassDefaultBehaviors(classType: ClassType, defaultBehaviors: DataClassBehaviors) {
-    classType.details.dataClassBehaviors = defaultBehaviors;
-    classType.details.flags |= ClassTypeFlags.DataClass;
-
-    if (defaultBehaviors.keywordOnlyParams) {
-        classType.details.flags |= ClassTypeFlags.DataClassKeywordOnlyParams;
-    }
-
-    if (!defaultBehaviors.generateEq) {
-        classType.details.flags |= ClassTypeFlags.SkipSynthesizedDataClassEq;
-    }
-
-    if (defaultBehaviors.generateOrder) {
-        classType.details.flags |= ClassTypeFlags.SynthesizedDataClassOrder;
-    }
-}
-
-export function applyDataClassDecorator(
-    evaluator: TypeEvaluator,
-    classType: ClassType,
-    defaultBehaviors: DataClassBehaviors,
-    callNode: CallNode | undefined
-) {
-    applyDataClassDefaultBehaviors(classType, defaultBehaviors);
-
-    if (callNode?.arguments) {
-        applyDataClassClassBehaviorOverrides(evaluator, classType, callNode.arguments);
-    }
-}