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

package/dist/analyzer/constructors.js

@@ -0,0 +1,513 @@
+"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) {
+    // 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 newMethodTypeResult = evaluator.getTypeOfClassMemberName(errorNode, type, 
+    /* isAccessedThroughObject */ false, '__new__', { method: 'get' }, 
+    /* diag */ undefined, 1 /* AccessClassMembersOnly */ |
+        4 /* SkipObjectBaseClass */ |
+        16 /* TreatConstructorAsClassMethod */, type);
+    let returnType;
+    let validatedArgExpressions = false;
+    let argumentErrors = false;
+    let isTypeIncomplete = false;
+    const overloadsUsedForCall = [];
+    let newMethodReturnType;
+    const useConstructorTransform = (0, constructorTransform_1.hasConstructorTransform)(type);
+    // If there is a constructor transform, evaluate all arguments speculatively
+    // so we can later re-evaluate them in the context of the transform.
+    evaluator.useSpeculativeMode(useConstructorTransform ? errorNode : undefined, () => {
+        var _a;
+        // Validate __new__ if it is present.
+        if (newMethodTypeResult) {
+            // Use speculative mode for arg expressions because we don't know whether
+            // we'll need to re-evaluate these expressions later for __init__.
+            const newCallResult = validateNewMethod(evaluator, errorNode, argList, type, skipUnknownArgCheck, inferenceContext, newMethodTypeResult, 
+            /* useSpeculativeModeForArgs */ true);
+            if (newCallResult.argumentErrors) {
+                argumentErrors = true;
+            }
+            else {
+                overloadsUsedForCall.push(...newCallResult.overloadsUsedForCall);
+            }
+            if (newCallResult.isTypeIncomplete) {
+                isTypeIncomplete = true;
+            }
+            newMethodReturnType = newCallResult.returnType;
+        }
+        if (!newMethodReturnType) {
+            newMethodReturnType = types_1.ClassType.cloneAsInstance(type);
+        }
+        else if (!(0, types_1.isNever)(newMethodReturnType)) {
+            if (!(0, types_1.isClassInstance)(newMethodReturnType)) {
+                // If the __new__ method returns something other than an object or
+                // NoReturn, we'll ignore its return type.
+                newMethodReturnType = types_1.ClassType.cloneAsInstance(type);
+            }
+            else if (types_1.ClassType.isSameGenericClass(newMethodReturnType, type) &&
+                (0, typeUtils_1.isPartlyUnknown)(newMethodReturnType)) {
+                // If the __new__ method returns the same type as the class it's constructing
+                // but doesn't supply solved type arguments, we'll ignore its return type
+                // and rely on the __init__ method to supply them instead.
+                newMethodReturnType = types_1.ClassType.cloneAsInstance(type);
+            }
+        }
+        let initMethodTypeResult;
+        // Validate __init__ if it's present. Skip if the __new__ method produced errors.
+        if (!argumentErrors &&
+            !(0, types_1.isNever)(newMethodReturnType) &&
+            !shouldSkipInitEvaluation(evaluator, type, newMethodReturnType)) {
+            // Determine whether the class overrides the object.__init__ method.
+            initMethodTypeResult = evaluator.getTypeOfObjectMember(errorNode, types_1.ClassType.cloneAsInstance(newMethodReturnType), '__init__', { method: 'get' }, 
+            /* diag */ undefined, 4 /* SkipObjectBaseClass */ | 64 /* SkipAttributeAccessOverride */);
+            // Validate __init__ if it's present.
+            if (initMethodTypeResult) {
+                const initCallResult = validateInitMethod(evaluator, errorNode, argList, newMethodReturnType, skipUnknownArgCheck, inferenceContext, initMethodTypeResult.type);
+                if (initCallResult.argumentErrors) {
+                    argumentErrors = true;
+                }
+                else {
+                    overloadsUsedForCall.push(...initCallResult.overloadsUsedForCall);
+                }
+                if (initCallResult.isTypeIncomplete) {
+                    isTypeIncomplete = true;
+                }
+                returnType = initCallResult.returnType;
+                validatedArgExpressions = true;
+                skipUnknownArgCheck = true;
+            }
+        }
+        if (!validatedArgExpressions && newMethodTypeResult) {
+            // If we skipped the __init__ method and the __new__ method was evaluated only
+            // speculatively, evaluate it non-speculatively now so we can report errors.
+            if (!evaluator.isSpeculativeModeInUse(errorNode)) {
+                validateNewMethod(evaluator, errorNode, argList, type, skipUnknownArgCheck, inferenceContext, newMethodTypeResult, 
+                /* useSpeculativeModeForArgs */ false);
+            }
+            validatedArgExpressions = true;
+            returnType = newMethodReturnType;
+        }
+        // If the class doesn't override object.__new__ or object.__init__, use the
+        // fallback constructor type evaluation for the `object` class.
+        if (!newMethodTypeResult && !initMethodTypeResult) {
+            const callResult = validateFallbackConstructorCall(evaluator, errorNode, argList, type, inferenceContext);
+            if (callResult.argumentErrors) {
+                argumentErrors = true;
+            }
+            else {
+                overloadsUsedForCall.push(...callResult.overloadsUsedForCall);
+            }
+            if (callResult.isTypeIncomplete) {
+                isTypeIncomplete = true;
+            }
+            returnType = (_a = callResult.returnType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
+        }
+    });
+    // Apply a constructor transform if applicable.
+    if (!argumentErrors && returnType && useConstructorTransform) {
+        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;
+        }
+        validatedArgExpressions = true;
+    }
+    // If we weren't able to validate the args, analyze the expressions here
+    // to mark symbols referenced and report expression evaluation errors.
+    if (!validatedArgExpressions) {
+        argList.forEach((arg) => {
+            if (arg.valueExpression && !evaluator.isSpeculativeModeInUse(arg.valueExpression)) {
+                evaluator.getTypeOfExpression(arg.valueExpression);
+            }
+        });
+    }
+    return { argumentErrors, returnType, isTypeIncomplete, overloadsUsedForCall };
+}
+exports.validateConstructorArguments = validateConstructorArguments;
+// Evaluates the __new__ method for type correctness. If useSpeculativeModeForArgs
+// is true, use speculative mode to evaluate the arguments (unless an argument
+// error is produced, in which case it's OK to use speculative mode).
+function validateNewMethod(evaluator, errorNode, argList, type, skipUnknownArgCheck, inferenceContext, newMethodTypeResult, useSpeculativeModeForArgs) {
+    let newReturnType;
+    let isTypeIncomplete = false;
+    let argumentErrors = false;
+    const overloadsUsedForCall = [];
+    const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(type));
+    typeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(newMethodTypeResult.type));
+    if (type.typeAliasInfo) {
+        typeVarContext.addSolveForScope(type.typeAliasInfo.typeVarScopeId);
+    }
+    const callResult = evaluator.useSpeculativeMode(useSpeculativeModeForArgs ? errorNode : undefined, () => {
+        return evaluator.validateCallArguments(errorNode, argList, newMethodTypeResult, typeVarContext, skipUnknownArgCheck, inferenceContext);
+    });
+    if (callResult.isTypeIncomplete) {
+        isTypeIncomplete = true;
+    }
+    if (callResult.argumentErrors) {
+        argumentErrors = true;
+        // Evaluate the arguments in a non-speculative manner to generate any diagnostics.
+        evaluator.validateCallArguments(errorNode, argList, newMethodTypeResult, typeVarContext, skipUnknownArgCheck);
+    }
+    else {
+        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)) {
+                    // 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 },
+                        ]);
+                    }
+                }
+            }
+        }
+    }
+    if (!newReturnType) {
+        newReturnType = applyExpectedTypeForConstructor(evaluator, type, inferenceContext, typeVarContext);
+    }
+    else if ((0, types_1.isClassInstance)(newReturnType) && (0, typeUtils_1.isTupleClass)(newReturnType) && !newReturnType.tupleTypeArguments) {
+        newReturnType = applyExpectedTypeForTupleConstructor(newReturnType, inferenceContext);
+    }
+    return { argumentErrors, returnType: newReturnType, isTypeIncomplete, overloadsUsedForCall };
+}
+function validateInitMethod(evaluator, errorNode, argList, type, skipUnknownArgCheck, inferenceContext, initMethodType) {
+    let returnType;
+    let isTypeIncomplete = false;
+    let argumentErrors = false;
+    const overloadsUsedForCall = [];
+    // If there is an expected type, analyze the __init__ call for each of the
+    // subtypes that comprise the expected type. If one or more analyzes with no
+    // errors, use those results. This requires special-case processing because
+    // the __init__ method doesn't return the expected type. It always
+    // returns None.
+    if (inferenceContext) {
+        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)(initMethodType));
+            if ((0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluator, types_1.ClassType.cloneAsInstance(type), expectedSubType, typeVarContext, (0, parseTreeUtils_1.getTypeVarScopesForNode)(errorNode))) {
+                const specializedConstructor = (0, typeUtils_1.applySolvedTypeVars)(initMethodType, typeVarContext);
+                let callResult;
+                callResult = evaluator.useSpeculativeMode(errorNode, () => {
+                    return 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, typeVarContext);
+                }
+            }
+            return undefined;
+        });
+        if ((0, types_1.isNever)(returnType) || argumentErrors) {
+            returnType = undefined;
+        }
+    }
+    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, adjustedClassType)) {
+            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);
+        }
+    }
+    return { argumentErrors, returnType, isTypeIncomplete, overloadsUsedForCall };
+}
+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;
+}
+function applyExpectedSubtypeForConstructor(evaluator, type, expectedSubtype, typeVarContext) {
+    const specializedType = (0, typeUtils_1.applySolvedTypeVars)(types_1.ClassType.cloneAsInstance(type), typeVarContext, {
+        applyInScopePlaceholders: true,
+    });
+    if (!evaluator.assignType(expectedSubtype, specializedType)) {
+        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, 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;
+// If __new__ returns a type that is not an instance of the class, skip the
+// __init__ method evaluation. This is consistent with the behavior of the
+// type.__call__ runtime behavior.
+function shouldSkipInitEvaluation(evaluator, classType, newMethodReturnType) {
+    const returnType = evaluator.makeTopLevelTypeVarsConcrete(newMethodReturnType);
+    let skipInitCheck = false;
+    (0, typeUtils_1.doForEachSubtype)(returnType, (subtype) => {
+        if ((0, types_1.isAnyOrUnknown)(subtype)) {
+            return;
+        }
+        if ((0, types_1.isClassInstance)(subtype)) {
+            const inheritanceChain = [];
+            const isDerivedFrom = types_1.ClassType.isDerivedFrom(subtype, classType, inheritanceChain);
+            if (!isDerivedFrom) {
+                skipInitCheck = true;
+            }
+            return;
+        }
+        skipInitCheck = true;
+    });
+    return skipInitCheck;
+}
+//# 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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"}