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

package/dist/analyzer/constructors.js

@@ -17,10 +17,7 @@ exports.createFunctionFromConstructor = exports.validateConstructorArguments = e
 const collectionUtils_1 = require("../common/collectionUtils");
 const diagnostic_1 = require("../common/diagnostic");
 const diagnosticRules_1 = require("../common/diagnosticRules");
-const localize_1 = require("../localization/localize");
-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");
@@ -50,11 +47,18 @@ exports.getBoundCallMethod = getBoundCallMethod;
 // 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, signatureTracker) {
-    var _a;
-    const metaclassResult = validateMetaclassCall(evaluator, errorNode, argList, type, skipUnknownArgCheck, inferenceContext, signatureTracker);
+function validateConstructorArguments(evaluator, errorNode, argList, type, skipUnknownArgCheck, inferenceContext) {
+    var _a, _b;
+    // If this is an unspecialized generic type alias, specialize it now
+    // using default type argument values.
+    const aliasInfo = (_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo;
+    if ((aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeParameters) && !aliasInfo.typeArguments) {
+        const typeAliasTypeVarContext = new typeVarContext_1.TypeVarContext(aliasInfo.typeVarScopeId);
+        type = (0, typeUtils_1.applySolvedTypeVars)(type, typeAliasTypeVarContext, { unknownIfNotFound: true });
+    }
+    const metaclassResult = validateMetaclassCall(evaluator, errorNode, argList, type, skipUnknownArgCheck, inferenceContext);
     if (metaclassResult) {
-        const metaclassReturnType = (_a = metaclassResult.returnType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
+        const metaclassReturnType = (_b = metaclassResult.returnType) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
         // If there a custom `__call__` method on the metaclass that returns
         // something other than an instance of the class, assume that it
         // overrides the normal `type.__call__` logic and don't perform the usual
@@ -73,7 +77,7 @@ function validateConstructorArguments(evaluator, errorNode, argList, type, skipU
     // If there is a constructor transform, evaluate all arguments speculatively
     // so we can later re-evaluate them in the context of the transform.
     const returnResult = evaluator.useSpeculativeMode(useConstructorTransform ? errorNode : undefined, () => {
-        return validateNewAndInitMethods(evaluator, errorNode, argList, type, skipUnknownArgCheck, inferenceContext, signatureTracker, newMethodTypeResult);
+        return validateNewAndInitMethods(evaluator, errorNode, argList, type, skipUnknownArgCheck, inferenceContext, newMethodTypeResult);
     });
     let validatedArgExpressions = !useConstructorTransform || returnResult.argumentErrors;
     // Apply a constructor transform if applicable.
@@ -82,7 +86,7 @@ function validateConstructorArguments(evaluator, errorNode, argList, type, skipU
             // If there were errors when validating the __new__ and __init__ methods,
             // we need to re-evaluate the arguments to generate error messages because
             // we previously evaluated them speculatively.
-            validateNewAndInitMethods(evaluator, errorNode, argList, type, skipUnknownArgCheck, inferenceContext, signatureTracker, newMethodTypeResult);
+            validateNewAndInitMethods(evaluator, errorNode, argList, type, skipUnknownArgCheck, inferenceContext, newMethodTypeResult);
             validatedArgExpressions = true;
         }
         else if (returnResult.returnType) {
@@ -90,7 +94,7 @@ function validateConstructorArguments(evaluator, errorNode, argList, type, skipU
                 argumentErrors: !!returnResult.argumentErrors,
                 returnType: returnResult.returnType,
                 isTypeIncomplete: !!returnResult.isTypeIncomplete,
-            }, signatureTracker);
+            });
             returnResult.returnType = transformed.returnType;
             if (transformed.isTypeIncomplete) {
                 returnResult.isTypeIncomplete = true;
@@ -113,7 +117,7 @@ function validateConstructorArguments(evaluator, errorNode, argList, type, skipU
     return returnResult;
 }
 exports.validateConstructorArguments = validateConstructorArguments;
-function validateNewAndInitMethods(evaluator, errorNode, argList, type, skipUnknownArgCheck, inferenceContext, signatureTracker, newMethodTypeResult) {
+function validateNewAndInitMethods(evaluator, errorNode, argList, type, skipUnknownArgCheck, inferenceContext, newMethodTypeResult) {
     var _a, _b;
     let returnType;
     let validatedArgExpressions = false;
@@ -125,7 +129,7 @@ function validateNewAndInitMethods(evaluator, errorNode, argList, type, skipUnkn
     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, signatureTracker, newMethodTypeResult, 
+        const newCallResult = validateNewMethod(evaluator, errorNode, argList, type, skipUnknownArgCheck, inferenceContext, newMethodTypeResult, 
         /* useSpeculativeModeForArgs */ true);
         if (newCallResult.argumentErrors) {
             argumentErrors = true;
@@ -166,8 +170,8 @@ function validateNewAndInitMethods(evaluator, errorNode, argList, type, skipUnkn
         // but didn't supply solved type arguments, we'll ignore its specialized return
         // type and rely on the __init__ method to supply the type arguments instead.
         let initMethodBindToType = newMethodReturnType;
-        if (initMethodBindToType.typeArguments &&
-            initMethodBindToType.typeArguments.some((typeArg) => (0, types_1.isUnknown)(typeArg))) {
+        if (initMethodBindToType.priv.typeArguments &&
+            initMethodBindToType.priv.typeArguments.some((typeArg) => (0, types_1.isUnknown)(typeArg))) {
             initMethodBindToType = types_1.ClassType.cloneAsInstance(type);
         }
         // Determine whether the class overrides the object.__init__ method.
@@ -178,7 +182,7 @@ function validateNewAndInitMethods(evaluator, errorNode, argList, type, skipUnkn
         }
         // Validate __init__ if it's present.
         if (initMethodTypeResult) {
-            const initCallResult = validateInitMethod(evaluator, errorNode, argList, initMethodBindToType, skipUnknownArgCheck, inferenceContext, signatureTracker, initMethodTypeResult.type);
+            const initCallResult = validateInitMethod(evaluator, errorNode, argList, initMethodBindToType, skipUnknownArgCheck, inferenceContext, initMethodTypeResult.type);
             if (initCallResult.argumentErrors) {
                 argumentErrors = true;
             }
@@ -197,7 +201,7 @@ function validateNewAndInitMethods(evaluator, errorNode, argList, type, skipUnkn
         // 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, signatureTracker, newMethodTypeResult, 
+            validateNewMethod(evaluator, errorNode, argList, type, skipUnknownArgCheck, inferenceContext, newMethodTypeResult, 
             /* useSpeculativeModeForArgs */ false);
         }
         validatedArgExpressions = true;
@@ -223,21 +227,15 @@ function validateNewAndInitMethods(evaluator, errorNode, argList, type, skipUnkn
 // 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, signatureTracker, newMethodTypeResult, useSpeculativeModeForArgs) {
+function validateNewMethod(evaluator, errorNode, argList, type, skipUnknownArgCheck, inferenceContext, newMethodTypeResult, useSpeculativeModeForArgs) {
     let newReturnType;
     let isTypeIncomplete = false;
     let argumentErrors = false;
     const overloadsUsedForCall = [];
-    if (signatureTracker) {
-        newMethodTypeResult.type = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(newMethodTypeResult.type, signatureTracker, errorNode.start);
-    }
     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, signatureTracker);
+        return evaluator.validateCallArguments(errorNode, argList, newMethodTypeResult, typeVarContext, skipUnknownArgCheck, inferenceContext);
     });
     if (callResult.isTypeIncomplete) {
         isTypeIncomplete = true;
@@ -246,7 +244,7 @@ function validateNewMethod(evaluator, errorNode, argList, type, skipUnknownArgCh
         argumentErrors = true;
         // Evaluate the arguments in a non-speculative manner to generate any diagnostics.
         typeVarContext.unlock();
-        evaluator.validateCallArguments(errorNode, argList, newMethodTypeResult, typeVarContext, skipUnknownArgCheck, inferenceContext, signatureTracker);
+        evaluator.validateCallArguments(errorNode, argList, newMethodTypeResult, typeVarContext, skipUnknownArgCheck, inferenceContext);
     }
     else {
         newReturnType = callResult.returnType;
@@ -257,10 +255,10 @@ function validateNewMethod(evaluator, errorNode, argList, type, skipUnknownArgCh
     if (newReturnType) {
         // Special-case the 'tuple' type specialization to use the homogenous
         // arbitrary-length form.
-        if ((0, types_1.isClassInstance)(newReturnType) && (0, typeUtils_1.isTupleClass)(newReturnType) && !newReturnType.tupleTypeArguments) {
-            if (newReturnType.typeArguments && newReturnType.typeArguments.length === 1) {
+        if ((0, types_1.isClassInstance)(newReturnType) && (0, typeUtils_1.isTupleClass)(newReturnType) && !newReturnType.priv.tupleTypeArguments) {
+            if (newReturnType.priv.typeArguments && newReturnType.priv.typeArguments.length === 1) {
                 newReturnType = (0, typeUtils_1.specializeTupleClass)(newReturnType, [
-                    { type: newReturnType.typeArguments[0], isUnbounded: true },
+                    { type: newReturnType.priv.typeArguments[0], isUnbounded: true },
                 ]);
             }
             newReturnType = applyExpectedTypeForTupleConstructor(newReturnType, inferenceContext);
@@ -271,153 +269,60 @@ function validateNewMethod(evaluator, errorNode, argList, type, skipUnknownArgCh
     }
     return { argumentErrors, returnType: newReturnType, isTypeIncomplete, overloadsUsedForCall };
 }
-function validateInitMethod(evaluator, errorNode, argList, type, skipUnknownArgCheck, inferenceContext, signatureTracker, initMethodType) {
-    let returnType;
+function validateInitMethod(evaluator, errorNode, argList, type, skipUnknownArgCheck, inferenceContext, initMethodType) {
     let isTypeIncomplete = false;
     let argumentErrors = false;
     const overloadsUsedForCall = [];
-    if (signatureTracker) {
-        initMethodType = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(initMethodType, signatureTracker, errorNode.start);
-    }
-    // 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) {
-        let foundWorkingExpectedType = false;
-        returnType = (0, typeUtils_1.mapSubtypes)(inferenceContext.expectedType, (expectedSubType) => {
-            // If we've already successfully evaluated the __init__ method with
-            // one expected type, ignore the remaining ones.
-            if (foundWorkingExpectedType) {
-                return undefined;
-            }
-            expectedSubType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expectedSubType);
-            // If the expected type is the same type as the class and the class
-            // is already explicitly specialized, don't override the explicit
-            // specialization.
-            if ((0, types_1.isClassInstance)(expectedSubType) &&
-                types_1.ClassType.isSameGenericClass(type, expectedSubType) &&
-                type.typeArguments) {
-                return undefined;
-            }
-            const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(type));
-            typeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(initMethodType));
-            if (!(0, constraintSolver_1.addConstraintsForExpectedType)(evaluator, types_1.ClassType.cloneAsInstance(type), expectedSubType, typeVarContext, (0, parseTreeUtils_1.getTypeVarScopesForNode)(errorNode), errorNode.start)) {
-                return undefined;
-            }
-            const specializedConstructor = (0, typeUtils_1.applySolvedTypeVars)(initMethodType, typeVarContext);
-            let callResult;
-            callResult = evaluator.useSpeculativeMode(errorNode, () => {
-                return evaluator.validateCallArguments(errorNode, argList, { type: specializedConstructor }, typeVarContext.clone(), skipUnknownArgCheck, 
-                /* inferenceContext */ undefined, signatureTracker);
-            });
-            if (callResult.argumentErrors) {
-                return undefined;
-            }
-            // Call validateCallArguments again, this time without speculative
-            // mode, so any errors are reported.
-            callResult = evaluator.validateCallArguments(errorNode, argList, { type: specializedConstructor }, typeVarContext, skipUnknownArgCheck, 
-            /* inferenceContext */ undefined, signatureTracker);
-            if (callResult.isTypeIncomplete) {
-                isTypeIncomplete = true;
-            }
-            if (callResult.argumentErrors) {
-                argumentErrors = true;
-            }
-            if (callResult.overloadsUsedForCall) {
-                (0, collectionUtils_1.appendArray)(overloadsUsedForCall, callResult.overloadsUsedForCall);
-            }
-            // Note that we've found an expected type that works.
-            foundWorkingExpectedType = true;
-            return applyExpectedSubtypeForConstructor(evaluator, type, expectedSubType, typeVarContext);
-        }, 
-        /* sortSubtypes */ true);
-        if ((0, types_1.isNever)(returnType) || argumentErrors) {
-            returnType = undefined;
-        }
+    const typeVarContext = type.priv.typeArguments
+        ? (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(type)
+        : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(type));
+    typeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(initMethodType));
+    const returnTypeOverride = (0, typeUtils_1.selfSpecializeClass)(type);
+    const callResult = evaluator.validateCallArguments(errorNode, argList, { type: initMethodType }, typeVarContext, skipUnknownArgCheck, inferenceContext ? { ...inferenceContext, returnTypeOverride } : undefined);
+    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);
+    }
+    const returnType = applyExpectedTypeForConstructor(evaluator, adjustedClassType, 
+    /* inferenceContext */ undefined, typeVarContext);
+    if (callResult.isTypeIncomplete) {
+        isTypeIncomplete = true;
     }
-    if (!returnType) {
-        const typeVarContext = type.typeArguments
-            ? (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(type)
-            : 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, 
-        /* inferenceContext */ undefined, signatureTracker);
-        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 if (callResult.overloadsUsedForCall) {
-            overloadsUsedForCall.push(...callResult.overloadsUsedForCall);
-        }
+    if (callResult.argumentErrors) {
+        argumentErrors = true;
+    }
+    else if (callResult.overloadsUsedForCall) {
+        overloadsUsedForCall.push(...callResult.overloadsUsedForCall);
     }
     return { argumentErrors, returnType, isTypeIncomplete, overloadsUsedForCall };
 }
 function validateFallbackConstructorCall(evaluator, errorNode, argList, type, inferenceContext) {
-    let reportedErrors = false;
-    // It's OK if the argument list consists only of `*args` and `**kwargs`.
-    if (argList.length > 0 && argList.some((arg) => arg.argumentCategory === 0 /* ArgumentCategory.Simple */)) {
-        evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.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) {
-        let expectedType = inferenceContext.expectedType;
-        // If the expectedType is a union, try to pick one that is likely to
-        // be the best choice.
-        if ((0, types_1.isUnion)(expectedType)) {
-            expectedType = (0, types_1.findSubtype)(expectedType, (subtype) => {
-                if ((0, types_1.isAnyOrUnknown)(subtype) || (0, types_1.isNever)(subtype)) {
-                    return false;
-                }
-                if ((0, types_1.isClass)(subtype) && evaluator.assignType(subtype, types_1.ClassType.cloneAsInstance(type))) {
-                    return true;
-                }
-                return false;
-            });
-        }
-        if (expectedType) {
-            (0, constraintSolver_1.addConstraintsForExpectedType)(evaluator, types_1.ClassType.cloneAsInstance(type), expectedType, typeVarContext, (0, parseTreeUtils_1.getTypeVarScopesForNode)(errorNode), errorNode.start);
-        }
-    }
-    return {
-        argumentErrors: reportedErrors,
-        overloadsUsedForCall: [],
-        returnType: applyExpectedTypeForConstructor(evaluator, type, inferenceContext, typeVarContext),
-    };
+    var _a;
+    // Bind the __new__ method from the object class.
+    const newMethodType = (_a = getBoundNewMethod(evaluator, errorNode, type, 
+    /* diag */ undefined, 0 /* MemberAccessFlags.Default */)) === null || _a === void 0 ? void 0 : _a.type;
+    // If there was no object.__new__ or it's not a callable, then something has
+    // gone terribly wrong in the typeshed stubs. To avoid crashing, simply
+    // return the instance.
+    if (!newMethodType || (!(0, types_1.isFunction)(newMethodType) && !(0, types_1.isOverloadedFunction)(newMethodType))) {
+        return { returnType: (0, typeUtils_1.convertToInstance)(type) };
+    }
+    return validateNewMethod(evaluator, errorNode, argList, type, 
+    /* skipUnknownArgCheck */ false, inferenceContext, { type: newMethodType }, 
+    /* useSpeculativeModeForArgs */ false);
 }
-function validateMetaclassCall(evaluator, errorNode, argList, type, skipUnknownArgCheck, inferenceContext, signatureTracker) {
+function validateMetaclassCall(evaluator, errorNode, argList, type, skipUnknownArgCheck, inferenceContext) {
     const metaclassCallMethodInfo = getBoundCallMethod(evaluator, errorNode, type);
     if (!metaclassCallMethodInfo) {
         return undefined;
     }
     const callResult = evaluator.validateCallArguments(errorNode, argList, metaclassCallMethodInfo, 
-    /* typeVarContext */ undefined, skipUnknownArgCheck, inferenceContext, signatureTracker);
+    /* typeVarContext */ undefined, skipUnknownArgCheck, inferenceContext);
     // If the return type is unannotated, don't use the inferred return type.
     const callType = metaclassCallMethodInfo.type;
-    if ((0, types_1.isFunction)(callType) && !callType.details.declaredReturnType) {
+    if ((0, types_1.isFunction)(callType) && !callType.shared.declaredReturnType) {
         return undefined;
     }
     // If the return type is unknown, ignore it.
@@ -445,7 +350,7 @@ function applyExpectedTypeForConstructor(evaluator, type, inferenceContext, type
     let unsolvedTypeVarsAreUnknown = true;
     // If this isn't a generic type or it's a type that has already been
     // explicitly specialized, the expected type isn't applicable.
-    if (type.details.typeParameters.length === 0 || type.typeArguments) {
+    if (type.shared.typeParameters.length === 0 || type.priv.typeArguments) {
         return (0, typeUtils_1.applySolvedTypeVars)(types_1.ClassType.cloneAsInstance(type), typeVarContext, { applyInScopePlaceholders: true });
     }
     if (inferenceContext) {
@@ -458,7 +363,7 @@ function applyExpectedTypeForConstructor(evaluator, type, inferenceContext, type
         // 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) {
+        if (type.priv.typeArguments) {
             unsolvedTypeVarsAreUnknown = false;
         }
     }
@@ -475,8 +380,8 @@ function applyExpectedTypeForTupleConstructor(type, inferenceContext) {
     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);
+        inferenceContext.expectedType.priv.tupleTypeArguments) {
+        specializedType = (0, typeUtils_1.specializeTupleClass)(type, inferenceContext.expectedType.priv.tupleTypeArguments);
     }
     return specializedType;
 }
@@ -513,7 +418,7 @@ function createFunctionFromConstructor(evaluator, classType, selfType = undefine
 }
 exports.createFunctionFromConstructor = createFunctionFromConstructor;
 function createFunctionFromMetaclassCall(evaluator, classType, recursionCount) {
-    const metaclass = classType.details.effectiveMetaclass;
+    const metaclass = classType.shared.effectiveMetaclass;
     if (!metaclass || !(0, types_1.isClass)(metaclass)) {
         return undefined;
     }
@@ -538,7 +443,7 @@ function createFunctionFromMetaclassCall(evaluator, classType, recursionCount) {
     // any of them returns something other than the instance of the class being
     // constructed.
     (0, typeUtils_1.doForEachSignature)(boundCallType, (signature) => {
-        if (signature.details.declaredReturnType) {
+        if (signature.shared.declaredReturnType) {
             const returnType = types_1.FunctionType.getEffectiveReturnType(signature);
             if (returnType && shouldSkipNewAndInitEvaluation(evaluator, classType, returnType)) {
                 useMetaclassCall = true;
@@ -559,13 +464,13 @@ function createFunctionFromNewMethod(evaluator, classType, selfType, recursionCo
         // If there are no parameters that include class-scoped type parameters,
         // self-specialize the class because the type arguments for the class
         // can't be solved if there are no parameters to supply them.
-        const hasParametersWithTypeVars = newSubtype.details.parameters.some((param, index) => {
+        const hasParametersWithTypeVars = newSubtype.shared.parameters.some((param, index) => {
             if (index === 0 || !param.name) {
                 return false;
             }
             const paramType = types_1.FunctionType.getEffectiveParameterType(newSubtype, index);
             const typeVars = (0, typeUtils_1.getTypeVarArgumentsRecursive)(paramType);
-            return typeVars.some((typeVar) => typeVar.scopeId === (0, typeUtils_1.getTypeVarScopeId)(classType));
+            return typeVars.some((typeVar) => typeVar.priv.scopeId === (0, typeUtils_1.getTypeVarScopeId)(classType));
         });
         const boundNew = evaluator.bindFunctionToClassOrObject(hasParametersWithTypeVars ? (0, typeUtils_1.selfSpecializeClass)(classType) : classType, newSubtype, newInfo && (0, types_1.isInstantiableClass)(newInfo.classType) ? newInfo.classType : undefined, 
         /* treatConstructorAsClassMethod */ true, selfType, 
@@ -574,12 +479,12 @@ function createFunctionFromNewMethod(evaluator, classType, selfType, recursionCo
             return undefined;
         }
         const convertedNew = types_1.FunctionType.clone(boundNew);
-        convertedNew.details.typeVarScopeId = newSubtype.details.typeVarScopeId;
-        if (!convertedNew.details.docString && classType.details.docString) {
-            convertedNew.details.docString = classType.details.docString;
+        convertedNew.shared.typeVarScopeId = newSubtype.shared.typeVarScopeId;
+        if (!convertedNew.shared.docString && classType.shared.docString) {
+            convertedNew.shared.docString = classType.shared.docString;
         }
-        convertedNew.details.flags &= ~(4 /* FunctionTypeFlags.StaticMethod */ | 1 /* FunctionTypeFlags.ConstructorMethod */);
-        convertedNew.details.constructorTypeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(classType);
+        convertedNew.shared.flags &= ~(4 /* FunctionTypeFlags.StaticMethod */ | 1 /* FunctionTypeFlags.ConstructorMethod */);
+        convertedNew.priv.constructorTypeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(classType);
         return convertedNew;
     };
     if ((0, types_1.isFunction)(newType)) {
@@ -589,7 +494,7 @@ function createFunctionFromNewMethod(evaluator, classType, selfType, recursionCo
         return undefined;
     }
     const newOverloads = [];
-    newType.overloads.forEach((overload) => {
+    newType.priv.overloads.forEach((overload) => {
         const converted = convertNewToConstructor(overload);
         if (converted) {
             newOverloads.push(converted);
@@ -606,14 +511,14 @@ function createFunctionFromNewMethod(evaluator, classType, selfType, recursionCo
 function createFunctionFromObjectNewMethod(classType) {
     // Return a fallback constructor based on the object.__new__ method.
     const constructorFunction = types_1.FunctionType.createSynthesizedInstance('__new__', 0 /* FunctionTypeFlags.None */);
-    constructorFunction.details.declaredReturnType = types_1.ClassType.cloneAsInstance(classType);
+    constructorFunction.shared.declaredReturnType = types_1.ClassType.cloneAsInstance(classType);
     // If this is type[T] or a protocol, we don't know what parameters are accepted
     // by the constructor, so add the default parameters.
-    if (classType.includeSubclasses || types_1.ClassType.isProtocolClass(classType)) {
+    if (classType.priv.includeSubclasses || types_1.ClassType.isProtocolClass(classType)) {
         types_1.FunctionType.addDefaultParameters(constructorFunction);
     }
-    if (!constructorFunction.details.docString && classType.details.docString) {
-        constructorFunction.details.docString = classType.details.docString;
+    if (!constructorFunction.shared.docString && classType.shared.docString) {
+        constructorFunction.shared.docString = classType.shared.docString;
     }
     return constructorFunction;
 }
@@ -641,12 +546,12 @@ function createFunctionFromInitMethod(evaluator, classType, selfType, recursionC
             returnType = objectType;
             // If this is a generic type, self-specialize the class (i.e. fill in
             // its own type parameters as type arguments).
-            if (objectType.details.typeParameters.length > 0 && !objectType.typeArguments) {
+            if (objectType.shared.typeParameters.length > 0 && !objectType.priv.typeArguments) {
                 const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(objectType));
                 // If a TypeVar is not used in any of the parameter types, it should take
                 // on its default value (typically Unknown) in the resulting specialized type.
                 const typeVarsInParams = [];
-                convertedInit.details.parameters.forEach((param, index) => {
+                convertedInit.shared.parameters.forEach((param, index) => {
                     const paramType = types_1.FunctionType.getEffectiveParameterType(convertedInit, index);
                     (0, typeUtils_1.addTypeVarsToListIfUnique)(typeVarsInParams, (0, typeUtils_1.getTypeVarArgumentsRecursive)(paramType));
                 });
@@ -664,15 +569,15 @@ function createFunctionFromInitMethod(evaluator, classType, selfType, recursionC
                 });
             }
         }
-        convertedInit.details.declaredReturnType = (_a = boundInit.strippedFirstParamType) !== null && _a !== void 0 ? _a : returnType;
-        if (convertedInit.specializedTypes) {
-            convertedInit.specializedTypes.returnType = returnType;
+        convertedInit.shared.declaredReturnType = (_a = boundInit.priv.strippedFirstParamType) !== null && _a !== void 0 ? _a : returnType;
+        if (convertedInit.priv.specializedTypes) {
+            convertedInit.priv.specializedTypes.returnType = returnType;
         }
-        if (!convertedInit.details.docString && classType.details.docString) {
-            convertedInit.details.docString = classType.details.docString;
+        if (!convertedInit.shared.docString && classType.shared.docString) {
+            convertedInit.shared.docString = classType.shared.docString;
         }
-        convertedInit.details.flags &= ~4 /* FunctionTypeFlags.StaticMethod */;
-        convertedInit.details.constructorTypeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(classType);
+        convertedInit.shared.flags &= ~4 /* FunctionTypeFlags.StaticMethod */;
+        convertedInit.priv.constructorTypeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(classType);
         return convertedInit;
     }
     if ((0, types_1.isFunction)(initType)) {
@@ -682,7 +587,7 @@ function createFunctionFromInitMethod(evaluator, classType, selfType, recursionC
         return undefined;
     }
     const initOverloads = [];
-    initType.overloads.forEach((overload) => {
+    initType.priv.overloads.forEach((overload) => {
         const converted = convertInitToConstructor(overload);
         if (converted) {
             initOverloads.push(converted);
@@ -740,15 +645,15 @@ function isDefaultNewMethod(newMethod) {
     if (!newMethod || !(0, types_1.isFunction)(newMethod)) {
         return false;
     }
-    const params = newMethod.details.parameters;
+    const params = newMethod.shared.parameters;
     if (params.length !== 2) {
         return false;
     }
     if (params[0].category !== 1 /* ParameterCategory.ArgsList */ || params[1].category !== 2 /* ParameterCategory.KwargsDict */) {
         return false;
     }
-    const returnType = (_a = newMethod.details.declaredReturnType) !== null && _a !== void 0 ? _a : newMethod.inferredReturnType;
-    if (!returnType || !(0, types_1.isTypeVar)(returnType) || !returnType.details.isSynthesizedSelf) {
+    const returnType = (_a = newMethod.shared.declaredReturnType) !== null && _a !== void 0 ? _a : newMethod.priv.inferredReturnType;
+    if (!returnType || !(0, types_1.isTypeVar)(returnType) || !returnType.shared.isSynthesizedSelf) {
         return false;
     }
     return true;