@zzzen/pyright-internal 1.2.0-dev.20230430 → 1.2.0-dev.20230507

package/dist/analyzer/constructors.d.ts

@@ -0,0 +1,6 @@
+import { ExpressionNode } from '../parser/parseNodes';
+import { CallResult, FunctionArgument, TypeEvaluator } from './typeEvaluatorTypes';
+import { InferenceContext } from './typeUtils';
+import { ClassType, FunctionType, OverloadedFunctionType } from './types';
+export declare function validateConstructorArguments(evaluator: TypeEvaluator, errorNode: ExpressionNode, argList: FunctionArgument[], type: ClassType, skipUnknownArgCheck: boolean, inferenceContext: InferenceContext | undefined): CallResult;
+export declare function createFunctionFromConstructor(evaluator: TypeEvaluator, classType: ClassType, recursionCount?: number): FunctionType | OverloadedFunctionType | undefined;

package/dist/analyzer/constructors.js

@@ -0,0 +1,456 @@
+"use strict";
+/*
+ * constructors.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * Provides type evaluation logic for constructors. A constructor
+ * in Python is implemented by a `__call__` method on the metaclass,
+ * which is typically the `type` class. The default implementation
+ * calls the `__new__` method on the class to allocate the object.
+ * If the resulting object is an instance of the class, it then calls
+ * the `__init__` method on the resulting object with the same arguments.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFunctionFromConstructor = exports.validateConstructorArguments = void 0;
+const diagnosticRules_1 = require("../common/diagnosticRules");
+const localize_1 = require("../localization/localize");
+const analyzerNodeInfo_1 = require("./analyzerNodeInfo");
+const constraintSolver_1 = require("./constraintSolver");
+const constructorTransform_1 = require("./constructorTransform");
+const parseTreeUtils_1 = require("./parseTreeUtils");
+const typeUtils_1 = require("./typeUtils");
+const typeVarContext_1 = require("./typeVarContext");
+const types_1 = require("./types");
+// Matches the arguments of a call to the constructor for a class.
+// If successful, it returns the resulting (specialized) object type that
+// is allocated by the constructor. If unsuccessful, it reports diagnostics.
+function validateConstructorArguments(evaluator, errorNode, argList, type, skipUnknownArgCheck, inferenceContext) {
+    var _a;
+    // If there a custom `__call__` method on the metaclass, assume that it
+    // overrides the normal `type.__call__` logic and don't perform the usual
+    // __new__ and __init__ validation.
+    const metaclassResult = validateMetaclassCall(evaluator, errorNode, argList, type, skipUnknownArgCheck, inferenceContext);
+    if (metaclassResult) {
+        return metaclassResult;
+    }
+    // Determine whether the class overrides the object.__new__ method.
+    const newMethodInfo = evaluator.getTypeOfClassMemberName(errorNode, type, 
+    /* isAccessedThroughObject */ false, '__new__', { method: 'get' }, 
+    /* diag */ undefined, 1 /* AccessClassMembersOnly */ |
+        4 /* SkipObjectBaseClass */ |
+        16 /* TreatConstructorAsClassMethod */, type);
+    // Determine whether the class overrides the object.__init__ method.
+    const initMethodInfo = evaluator.getTypeOfObjectMember(errorNode, types_1.ClassType.cloneAsInstance(type), '__init__', { method: 'get' }, 
+    /* diag */ undefined, 4 /* SkipObjectBaseClass */ | 64 /* SkipAttributeAccessOverride */);
+    let returnType;
+    let validatedTypes = false;
+    let argumentErrors = false;
+    let isTypeIncomplete = false;
+    const overloadsUsedForCall = [];
+    // If the class doesn't override object.__new__ or object.__init__, use the
+    // fallback constructor type evaluation for the `object` class.
+    if (!newMethodInfo && !initMethodInfo) {
+        const callResult = validateFallbackConstructorCall(evaluator, errorNode, argList, type, inferenceContext);
+        if (callResult.argumentErrors) {
+            argumentErrors = true;
+        }
+        else {
+            overloadsUsedForCall.push(...callResult.overloadsUsedForCall);
+        }
+        returnType = (_a = callResult.returnType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
+    }
+    else {
+        // Validate __init__
+        // We validate __init__ before __new__ because the former typically has
+        // more specific type annotations, and we want to evaluate the arguments
+        // in the context of these types. The __new__ method often uses generic
+        // vargs and kwargs.
+        const initMethodType = initMethodInfo === null || initMethodInfo === void 0 ? void 0 : initMethodInfo.type;
+        if (initMethodType && !shouldSkipConstructorCheck(initMethodType)) {
+            // If there is an expected type, analyze the constructor call
+            // for each of the subtypes that comprise the expected type. If
+            // one or more analyzes with no errors, use those results.
+            if (inferenceContext) {
+                const expectedCallResult = validateConstructorMethodWithContext(evaluator, errorNode, argList, type, skipUnknownArgCheck, inferenceContext, initMethodType);
+                if (expectedCallResult && !expectedCallResult.argumentErrors) {
+                    returnType = expectedCallResult.returnType;
+                    if (expectedCallResult.isTypeIncomplete) {
+                        isTypeIncomplete = true;
+                    }
+                }
+            }
+            if (!returnType) {
+                const typeVarContext = type.typeArguments
+                    ? (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(type, /* makeConcrete */ false)
+                    : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(type));
+                typeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(initMethodType));
+                const callResult = evaluator.validateCallArguments(errorNode, argList, { type: initMethodType }, typeVarContext, skipUnknownArgCheck);
+                let adjustedClassType = type;
+                if (callResult.specializedInitSelfType &&
+                    (0, types_1.isClassInstance)(callResult.specializedInitSelfType) &&
+                    types_1.ClassType.isSameGenericClass(callResult.specializedInitSelfType, type)) {
+                    adjustedClassType = types_1.ClassType.cloneAsInstantiable(callResult.specializedInitSelfType);
+                }
+                returnType = applyExpectedTypeForConstructor(evaluator, adjustedClassType, 
+                /* inferenceContext */ undefined, typeVarContext);
+                if (callResult.isTypeIncomplete) {
+                    isTypeIncomplete = true;
+                }
+                if (callResult.argumentErrors) {
+                    argumentErrors = true;
+                }
+                else {
+                    overloadsUsedForCall.push(...callResult.overloadsUsedForCall);
+                }
+            }
+            validatedTypes = true;
+            skipUnknownArgCheck = true;
+        }
+        // Validate __new__
+        // Don't report errors for __new__ if __init__ already generated errors. They're
+        // probably going to be entirely redundant anyway.
+        if (!argumentErrors && newMethodInfo && !shouldSkipConstructorCheck(newMethodInfo.type)) {
+            const constructorMethodType = newMethodInfo.type;
+            let newReturnType;
+            // If there is an expected type that was not applied above when
+            // handling the __init__ method, try to apply it with the __new__ method.
+            if (inferenceContext && !returnType) {
+                const expectedCallResult = validateConstructorMethodWithContext(evaluator, errorNode, argList, type, skipUnknownArgCheck, inferenceContext, constructorMethodType);
+                if (expectedCallResult && !expectedCallResult.argumentErrors) {
+                    newReturnType = expectedCallResult.returnType;
+                    returnType = newReturnType;
+                    if (expectedCallResult.isTypeIncomplete) {
+                        isTypeIncomplete = true;
+                    }
+                }
+            }
+            const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(type));
+            if (type.typeAliasInfo) {
+                typeVarContext.addSolveForScope(type.typeAliasInfo.typeVarScopeId);
+            }
+            typeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(constructorMethodType));
+            // Use speculative mode if we're going to later apply a constructor transform.
+            // This allows us to use bidirectional type inference for arguments in the transform.
+            const callResult = evaluator.useSpeculativeMode((0, constructorTransform_1.hasConstructorTransform)(type) ? errorNode : undefined, () => {
+                return evaluator.validateCallArguments(errorNode, argList, newMethodInfo, typeVarContext, skipUnknownArgCheck);
+            });
+            if (callResult.isTypeIncomplete) {
+                isTypeIncomplete = true;
+            }
+            if (callResult.argumentErrors) {
+                argumentErrors = true;
+            }
+            else if (!newReturnType) {
+                newReturnType = callResult.returnType;
+                if (overloadsUsedForCall.length === 0) {
+                    overloadsUsedForCall.push(...callResult.overloadsUsedForCall);
+                }
+                // If the constructor returned an object whose type matches the class of
+                // the original type being constructed, use the return type in case it was
+                // specialized. If it doesn't match, we'll fall back on the assumption that
+                // the constructed type is an instance of the class type. We need to do this
+                // in cases where we're inferring the return type based on a call to
+                // super().__new__().
+                if (newReturnType) {
+                    if ((0, types_1.isClassInstance)(newReturnType) && types_1.ClassType.isSameGenericClass(newReturnType, type)) {
+                        // If the specialized return type derived from the __init__
+                        // method is "better" than the return type provided by the
+                        // __new__ method (where "better" means that the type arguments
+                        // are all known), stick with the __init__ result.
+                        if ((!(0, typeUtils_1.isPartlyUnknown)(newReturnType) && !(0, typeUtils_1.requiresSpecialization)(newReturnType)) ||
+                            returnType === undefined) {
+                            // Special-case the 'tuple' type specialization to use
+                            // the homogenous arbitrary-length form.
+                            if ((0, types_1.isClassInstance)(newReturnType) &&
+                                types_1.ClassType.isTupleClass(newReturnType) &&
+                                !newReturnType.tupleTypeArguments &&
+                                newReturnType.typeArguments &&
+                                newReturnType.typeArguments.length === 1) {
+                                newReturnType = (0, typeUtils_1.specializeTupleClass)(newReturnType, [
+                                    { type: newReturnType.typeArguments[0], isUnbounded: true },
+                                ]);
+                            }
+                            returnType = newReturnType;
+                        }
+                    }
+                    else if (!returnType && !(0, types_1.isUnknown)(newReturnType)) {
+                        returnType = newReturnType;
+                    }
+                }
+            }
+            if (!returnType) {
+                returnType = applyExpectedTypeForConstructor(evaluator, type, inferenceContext, typeVarContext);
+            }
+            else if ((0, types_1.isClassInstance)(returnType) && (0, typeUtils_1.isTupleClass)(returnType) && !returnType.tupleTypeArguments) {
+                returnType = applyExpectedTypeForTupleConstructor(returnType, inferenceContext);
+            }
+            validatedTypes = true;
+        }
+    }
+    // If we weren't able to validate the args, analyze the expressions here
+    // to mark symbols referenced and report expression evaluation errors.
+    if (!validatedTypes) {
+        argList.forEach((arg) => {
+            if (arg.valueExpression && !evaluator.isSpeculativeModeInUse(arg.valueExpression)) {
+                evaluator.getTypeOfExpression(arg.valueExpression);
+            }
+        });
+    }
+    // Apply a constructor transform if applicable.
+    if (!argumentErrors && returnType) {
+        const transformed = (0, constructorTransform_1.applyConstructorTransform)(evaluator, errorNode, argList, type, {
+            argumentErrors,
+            returnType,
+            isTypeIncomplete,
+        });
+        returnType = transformed.returnType;
+        if (transformed.isTypeIncomplete) {
+            isTypeIncomplete = true;
+        }
+        if (transformed.argumentErrors) {
+            argumentErrors = true;
+        }
+    }
+    return { argumentErrors, returnType, isTypeIncomplete, overloadsUsedForCall };
+}
+exports.validateConstructorArguments = validateConstructorArguments;
+function validateFallbackConstructorCall(evaluator, errorNode, argList, type, inferenceContext) {
+    let reportedErrors = false;
+    if (argList.length > 0) {
+        const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(errorNode);
+        evaluator.addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.constructorNoArgs().format({ type: type.aliasName || type.details.name }), errorNode);
+        reportedErrors = true;
+    }
+    if (!inferenceContext && type.typeArguments) {
+        // If there was no expected type but the type was already specialized,
+        // assume that we're constructing an instance of the specialized type.
+        return {
+            argumentErrors: reportedErrors,
+            overloadsUsedForCall: [],
+            returnType: (0, typeUtils_1.convertToInstance)(type),
+        };
+    }
+    // Do our best to specialize the instantiated class based on the expected
+    // type if provided.
+    const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(type));
+    if (inferenceContext) {
+        (0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluator, types_1.ClassType.cloneAsInstance(type), inferenceContext.expectedType, typeVarContext, (0, parseTreeUtils_1.getTypeVarScopesForNode)(errorNode));
+    }
+    return {
+        argumentErrors: reportedErrors,
+        overloadsUsedForCall: [],
+        returnType: applyExpectedTypeForConstructor(evaluator, type, inferenceContext, typeVarContext),
+    };
+}
+function validateMetaclassCall(evaluator, errorNode, argList, type, skipUnknownArgCheck, inferenceContext) {
+    const metaclass = type.details.effectiveMetaclass;
+    if (metaclass && (0, types_1.isInstantiableClass)(metaclass) && !types_1.ClassType.isSameGenericClass(metaclass, type)) {
+        const metaclassCallMethodInfo = evaluator.getTypeOfClassMemberName(errorNode, metaclass, 
+        /* isAccessedThroughObject */ true, '__call__', { method: 'get' }, 
+        /* diag */ undefined, 32 /* ConsiderMetaclassOnly */ |
+            256 /* SkipTypeBaseClass */ |
+            64 /* SkipAttributeAccessOverride */, type);
+        if (metaclassCallMethodInfo) {
+            const callResult = evaluator.validateCallArguments(errorNode, argList, metaclassCallMethodInfo, 
+            /* typeVarContext */ undefined, skipUnknownArgCheck, inferenceContext);
+            if (!callResult.returnType || (0, types_1.isUnknown)(callResult.returnType)) {
+                // The return result isn't known. We'll assume in this case that
+                // the metaclass __call__ method allocated a new instance of the
+                // requested class.
+                const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(type));
+                callResult.returnType = applyExpectedTypeForConstructor(evaluator, type, inferenceContext, typeVarContext);
+            }
+            return callResult;
+        }
+    }
+    return undefined;
+}
+// For a constructor call that targets a generic class and an "expected type"
+// (i.e. bidirectional inference), this function attempts to infer the correct
+// specialized return type for the constructor.
+function validateConstructorMethodWithContext(evaluator, errorNode, argList, type, skipUnknownArgCheck, inferenceContext, constructorMethodType) {
+    let isTypeIncomplete = false;
+    let argumentErrors = false;
+    const overloadsUsedForCall = [];
+    const returnType = (0, typeUtils_1.mapSubtypes)(inferenceContext.expectedType, (expectedSubType) => {
+        expectedSubType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expectedSubType);
+        const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(type));
+        typeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(constructorMethodType));
+        if ((0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluator, types_1.ClassType.cloneAsInstance(type), expectedSubType, typeVarContext, (0, parseTreeUtils_1.getTypeVarScopesForNode)(errorNode))) {
+            const specializedConstructor = (0, typeUtils_1.applySolvedTypeVars)(constructorMethodType, typeVarContext);
+            let callResult;
+            evaluator.useSpeculativeMode(errorNode, () => {
+                callResult = evaluator.validateCallArguments(errorNode, argList, { type: specializedConstructor }, typeVarContext.clone(), skipUnknownArgCheck);
+            });
+            if (!callResult.argumentErrors) {
+                // Call validateCallArguments again, this time without speculative
+                // mode, so any errors are reported.
+                callResult = evaluator.validateCallArguments(errorNode, argList, { type: specializedConstructor }, typeVarContext, skipUnknownArgCheck);
+                if (callResult.isTypeIncomplete) {
+                    isTypeIncomplete = true;
+                }
+                if (callResult.argumentErrors) {
+                    argumentErrors = true;
+                }
+                overloadsUsedForCall.push(...callResult.overloadsUsedForCall);
+                return applyExpectedSubtypeForConstructor(evaluator, type, expectedSubType, inferenceContext, typeVarContext);
+            }
+        }
+        return undefined;
+    });
+    if ((0, types_1.isNever)(returnType)) {
+        return undefined;
+    }
+    return { returnType, isTypeIncomplete, argumentErrors, overloadsUsedForCall };
+}
+function applyExpectedSubtypeForConstructor(evaluator, type, expectedSubtype, inferenceContext, typeVarContext) {
+    var _a;
+    const specializedType = (0, typeUtils_1.applySolvedTypeVars)(types_1.ClassType.cloneAsInstance(type), typeVarContext);
+    if (!evaluator.assignType(expectedSubtype, specializedType, 
+    /* diag */ undefined, 
+    /* destTypeVarContext */ (_a = inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext) === null || _a === void 0 ? void 0 : _a.clone(), 
+    /* srcTypeVarContext */ undefined)) {
+        return undefined;
+    }
+    // If the expected type is "Any", transform it to an Any.
+    if ((0, types_1.isAny)(expectedSubtype)) {
+        return expectedSubtype;
+    }
+    return specializedType;
+}
+// Handles the case where a constructor is a generic type and the type
+// arguments are not specified but can be provided by the expected type.
+function applyExpectedTypeForConstructor(evaluator, type, inferenceContext, typeVarContext) {
+    let unsolvedTypeVarsAreUnknown = true;
+    if (inferenceContext) {
+        const specializedExpectedType = (0, typeUtils_1.mapSubtypes)(inferenceContext.expectedType, (expectedSubtype) => {
+            return applyExpectedSubtypeForConstructor(evaluator, type, expectedSubtype, inferenceContext, typeVarContext);
+        });
+        if (!(0, types_1.isNever)(specializedExpectedType)) {
+            return specializedExpectedType;
+        }
+        // If the expected type didn't provide TypeVar values, remaining
+        // unsolved TypeVars should be considered Unknown unless they were
+        // provided explicitly in the constructor call.
+        if (type.typeArguments) {
+            unsolvedTypeVarsAreUnknown = false;
+        }
+    }
+    const specializedType = (0, typeUtils_1.applySolvedTypeVars)(type, typeVarContext, {
+        unknownIfNotFound: unsolvedTypeVarsAreUnknown,
+    });
+    return types_1.ClassType.cloneAsInstance(specializedType);
+}
+// Similar to applyExpectedTypeForConstructor, this function handles the
+// special case of the tuple class.
+function applyExpectedTypeForTupleConstructor(type, inferenceContext) {
+    let specializedType = type;
+    if (inferenceContext &&
+        (0, types_1.isClassInstance)(inferenceContext.expectedType) &&
+        (0, typeUtils_1.isTupleClass)(inferenceContext.expectedType) &&
+        inferenceContext.expectedType.tupleTypeArguments) {
+        specializedType = (0, typeUtils_1.specializeTupleClass)(type, inferenceContext.expectedType.tupleTypeArguments);
+    }
+    return specializedType;
+}
+// Synthesize a function that represents the constructor for this class
+// taking into consideration the __init__ and __new__ methods.
+function createFunctionFromConstructor(evaluator, classType, recursionCount = 0) {
+    // Use the __init__ method if available. It's usually more detailed.
+    const initInfo = (0, typeUtils_1.lookUpClassMember)(classType, '__init__', 8 /* SkipInstanceVariables */ | 4 /* SkipObjectBaseClass */);
+    if (initInfo) {
+        const initType = evaluator.getTypeOfMember(initInfo);
+        const objectType = types_1.ClassType.cloneAsInstance(classType);
+        const convertInitToConstructor = (initSubtype) => {
+            let constructorFunction = evaluator.bindFunctionToClassOrObject(objectType, initSubtype, 
+            /* memberClass */ undefined, 
+            /* errorNode */ undefined, recursionCount);
+            if (constructorFunction) {
+                constructorFunction = types_1.FunctionType.clone(constructorFunction);
+                constructorFunction.details.declaredReturnType = objectType;
+                if (constructorFunction.specializedTypes) {
+                    constructorFunction.specializedTypes.returnType = objectType;
+                }
+                if (!constructorFunction.details.docString && classType.details.docString) {
+                    constructorFunction.details.docString = classType.details.docString;
+                }
+                constructorFunction.details.flags &= ~4 /* StaticMethod */;
+            }
+            return constructorFunction;
+        };
+        if ((0, types_1.isFunction)(initType)) {
+            return convertInitToConstructor(initType);
+        }
+        else if ((0, types_1.isOverloadedFunction)(initType)) {
+            const initOverloads = [];
+            initType.overloads.forEach((overload) => {
+                const converted = convertInitToConstructor(overload);
+                if (converted) {
+                    initOverloads.push(converted);
+                }
+            });
+            if (initOverloads.length === 0) {
+                return undefined;
+            }
+            else if (initOverloads.length === 1) {
+                return initOverloads[0];
+            }
+            return types_1.OverloadedFunctionType.create(initOverloads);
+        }
+    }
+    // Fall back on the __new__ method if __init__ isn't available.
+    const newInfo = (0, typeUtils_1.lookUpClassMember)(classType, '__new__', 8 /* SkipInstanceVariables */ | 4 /* SkipObjectBaseClass */);
+    if (newInfo) {
+        const newType = evaluator.getTypeOfMember(newInfo);
+        const convertNewToConstructor = (newSubtype) => {
+            let constructorFunction = evaluator.bindFunctionToClassOrObject(classType, newSubtype, 
+            /* memberClass */ undefined, 
+            /* errorNode */ undefined, recursionCount, 
+            /* treatConstructorAsClassMember */ true);
+            if (constructorFunction) {
+                constructorFunction = types_1.FunctionType.clone(constructorFunction);
+                if (!constructorFunction.details.docString && classType.details.docString) {
+                    constructorFunction.details.docString = classType.details.docString;
+                }
+                constructorFunction.details.flags &= ~(4 /* StaticMethod */ | 1 /* ConstructorMethod */);
+            }
+            return constructorFunction;
+        };
+        if ((0, types_1.isFunction)(newType)) {
+            return convertNewToConstructor(newType);
+        }
+        else if ((0, types_1.isOverloadedFunction)(newType)) {
+            const newOverloads = [];
+            newType.overloads.forEach((overload) => {
+                const converted = convertNewToConstructor(overload);
+                if (converted) {
+                    newOverloads.push(converted);
+                }
+            });
+            if (newOverloads.length === 0) {
+                return undefined;
+            }
+            else if (newOverloads.length === 1) {
+                return newOverloads[0];
+            }
+            return types_1.OverloadedFunctionType.create(newOverloads);
+        }
+    }
+    // Return a generic constructor.
+    const constructorFunction = types_1.FunctionType.createSynthesizedInstance('__new__', 0 /* None */);
+    constructorFunction.details.declaredReturnType = types_1.ClassType.cloneAsInstance(classType);
+    types_1.FunctionType.addDefaultParameters(constructorFunction);
+    if (!constructorFunction.details.docString && classType.details.docString) {
+        constructorFunction.details.docString = classType.details.docString;
+    }
+    return constructorFunction;
+}
+exports.createFunctionFromConstructor = createFunctionFromConstructor;
+// Determines whether we should skip argument validation. This is required
+// for certain synthesized constructor types, namely NamedTuples.
+function shouldSkipConstructorCheck(type) {
+    return (0, types_1.isFunction)(type) && types_1.FunctionType.isSkipConstructorCheck(type);
+}
+//# sourceMappingURL=constructors.js.map

package/dist/analyzer/constructors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constructors.js","sourceRoot":"","sources":["../../../src/analyzer/constructors.ts"],"names":[],"mappings":"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"}

package/dist/analyzer/dataClasses.js

@@ -30,9 +30,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
 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 diagnostic_1 = require("../common/diagnostic");
 const diagnosticRules_1 = require("../common/diagnosticRules");
 const localize_1 = require("../localization/localize");
 const AnalyzerNodeInfo = __importStar(require("./analyzerNodeInfo"));
+const constructors_1 = require("./constructors");
 const namedTuples_1 = require("./namedTuples");
 const parseTreeUtils_1 = require("./parseTreeUtils");
 const staticExpressions_1 = require("./staticExpressions");
@@ -118,6 +120,7 @@ function synthesizeDataClassMethods(evaluator, node, classType, skipSynthesizeIn
                 let isKeywordOnly = types_1.ClassType.isDataClassKeywordOnlyParams(classType) || sawKeywordOnlySeparator;
                 let defaultValueExpression;
                 let includeInInit = true;
+                let converter;
                 if (statement.nodeType === 3 /* Assignment */) {
                     if (statement.leftExpression.nodeType === 54 /* TypeAnnotation */ &&
                         statement.leftExpression.valueExpression.nodeType === 38 /* Name */) {
@@ -209,6 +212,10 @@ function synthesizeDataClassMethods(evaluator, node, classType, skipSynthesizeIn
                                     aliasName = valueType.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 = converterArg;
+                            }
                         }
                     }
                 }
@@ -258,6 +265,7 @@ function synthesizeDataClassMethods(evaluator, node, classType, skipSynthesizeIn
                             nameNode: variableNameNode,
                             type: types_1.UnknownType.create(),
                             isClassVar: true,
+                            converter,
                         };
                         localDataClassEntries.push(dataClassEntry);
                     }
@@ -276,6 +284,7 @@ function synthesizeDataClassMethods(evaluator, node, classType, skipSynthesizeIn
                             nameNode: variableNameNode,
                             type: types_1.UnknownType.create(),
                             isClassVar: false,
+                            converter,
                         };
                         localEntryTypeEvaluator.push({ entry: dataClassEntry, evaluator: variableTypeEvaluator });
                         // Add the new entry to the local entry list.
@@ -367,6 +376,9 @@ function synthesizeDataClassMethods(evaluator, node, classType, skipSynthesizeIn
                     // 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);
+                    if (entry.converter) {
+                        effectiveType = getConverterInputType(evaluator, entry.converter, effectiveType, entry.name);
+                    }
                     const effectiveName = entry.alias || entry.name;
                     if (!entry.alias && entry.nameNode && (0, symbolNameUtils_1.isPrivateName)(entry.nameNode.value)) {
                         evaluator.addError(localize_1.Localizer.Diagnostic.dataClassFieldWithPrivateName(), entry.nameNode);
@@ -492,6 +504,78 @@ function synthesizeDataClassMethods(evaluator, node, classType, skipSynthesizeIn
     }
 }
 exports.synthesizeDataClassMethods = synthesizeDataClassMethods;
+// Validates converter and, if valid, returns its input type. If invalid,
+// fieldType is returned.
+function getConverterInputType(evaluator, converterNode, fieldType, fieldName) {
+    var _a;
+    const converterType = getConverterAsFunction(evaluator, evaluator.getTypeOfExpression(converterNode.valueExpression).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);
+    const targetFunction = types_1.FunctionType.createSynthesizedInstance('');
+    targetFunction.details.typeVarScopeId = typeVar.scopeId;
+    targetFunction.details.declaredReturnType = fieldType;
+    types_1.FunctionType.addParameter(targetFunction, {
+        category: 0 /* Simple */,
+        name: '__input',
+        type: typeVar,
+        hasDeclaredType: true,
+    });
+    types_1.FunctionType.addParameter(targetFunction, {
+        category: 0 /* Simple */,
+        name: '',
+        type: types_1.UnknownType.create(),
+    });
+    if ((0, types_1.isFunction)(converterType)) {
+        const typeVarContext = new typeVarContext_1.TypeVarContext(typeVar.scopeId);
+        const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+        if (evaluator.assignType(targetFunction, converterType, diagAddendum, typeVarContext)) {
+            const solution = (0, typeUtils_1.applySolvedTypeVars)(typeVar, typeVarContext, { unknownIfNotFound: true });
+            return solution;
+        }
+        evaluator.addDiagnostic(AnalyzerNodeInfo.getFileInfo(converterNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.dataClassConverterFunction().format({
+            argType: evaluator.printType(converterType),
+            fieldType: evaluator.printType(fieldType),
+            fieldName: fieldName,
+        }) + diagAddendum.getString(), converterNode, (_a = diagAddendum.getEffectiveTextRange()) !== null && _a !== void 0 ? _a : converterNode);
+    }
+    else {
+        const acceptedTypes = [];
+        const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+        types_1.OverloadedFunctionType.getOverloads(converterType).forEach((overload) => {
+            const typeVarContext = new typeVarContext_1.TypeVarContext(typeVar.scopeId);
+            if (evaluator.assignType(targetFunction, overload, diagAddendum, typeVarContext)) {
+                const overloadSolution = (0, typeUtils_1.applySolvedTypeVars)(typeVar, typeVarContext, { unknownIfNotFound: true });
+                acceptedTypes.push(overloadSolution);
+            }
+        });
+        if (acceptedTypes.length > 0) {
+            return (0, types_1.combineTypes)(acceptedTypes);
+        }
+        evaluator.addDiagnostic(AnalyzerNodeInfo.getFileInfo(converterNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.dataClassConverterOverloads().format({
+            funcName: converterType.overloads[0].details.name || '<anonymous function>',
+            fieldType: evaluator.printType(fieldType),
+            fieldName: fieldName,
+        }) + diagAddendum.getString(), converterNode);
+    }
+    return fieldType;
+}
+function getConverterAsFunction(evaluator, converterType) {
+    if ((0, types_1.isFunction)(converterType) || (0, types_1.isOverloadedFunction)(converterType)) {
+        return converterType;
+    }
+    if ((0, types_1.isClassInstance)(converterType)) {
+        return evaluator.getBoundMethod(converterType, '__call__');
+    }
+    if ((0, types_1.isInstantiableClass)(converterType)) {
+        return (0, constructors_1.createFunctionFromConstructor)(evaluator, converterType);
+    }
+    return undefined;
+}
 // 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.