@zzzen/pyright-internal 1.2.0-dev.20240630 → 1.2.0-dev.20240714

package/dist/analyzer/typePrinter.js

@@ -94,8 +94,8 @@ function printObjectTypeForClass(type, printTypeFlags, returnTypeCallback) {
 exports.printObjectTypeForClass = printObjectTypeForClass;
 const maxLiteralStringLength = 50;
 function isLiteralValueTruncated(type) {
-    if (typeof type.literalValue === 'string') {
-        if (type.literalValue.length > maxLiteralStringLength) {
+    if (typeof type.priv.literalValue === 'string') {
+        if (type.priv.literalValue.length > maxLiteralStringLength) {
             return true;
         }
     }
@@ -103,15 +103,15 @@ function isLiteralValueTruncated(type) {
 }
 exports.isLiteralValueTruncated = isLiteralValueTruncated;
 function printLiteralValueTruncated(type) {
-    if (type.details.name === 'bytes') {
+    if (type.shared.name === 'bytes') {
         return 'bytes';
     }
-    (0, debug_1.assert)(type.details.name === 'str');
+    (0, debug_1.assert)(type.shared.name === 'str');
     return 'LiteralString';
 }
 exports.printLiteralValueTruncated = printLiteralValueTruncated;
 function printLiteralValue(type, quotation = "'") {
-    const literalValue = type.literalValue;
+    const literalValue = type.priv.literalValue;
     if (literalValue === undefined) {
         return '';
     }
@@ -122,7 +122,7 @@ function printLiteralValue(type, quotation = "'") {
         if (literalValue.length > maxLiteralStringLength) {
             effectiveLiteralValue = literalValue.substring(0, maxLiteralStringLength) + '…';
         }
-        if (type.details.name === 'bytes') {
+        if (type.shared.name === 'bytes') {
             let bytesString = '';
             // There's no good built-in conversion routine in javascript to convert
             // bytes strings. Determine on a character-by-character basis whether
@@ -175,6 +175,7 @@ function printLiteralValue(type, quotation = "'") {
 }
 exports.printLiteralValue = printLiteralValue;
 function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount) {
+    var _a, _b, _c;
     const originalPrintTypeFlags = printTypeFlags;
     const parenthesizeUnion = (printTypeFlags & 16 /* PrintTypeFlags.ParenthesizeUnion */) !== 0;
     printTypeFlags &= ~(16 /* PrintTypeFlags.ParenthesizeUnion */ | 128 /* PrintTypeFlags.ParenthesizeCallable */);
@@ -187,7 +188,8 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
     recursionCount++;
     // If this is a type alias, see if we should use its name rather than
     // the type it represents.
-    if (type.typeAliasInfo) {
+    const aliasInfo = (_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo;
+    if (aliasInfo) {
         let expandTypeAlias = true;
         if ((printTypeFlags & 32 /* PrintTypeFlags.ExpandTypeAlias */) === 0) {
             expandTypeAlias = false;
@@ -201,30 +203,30 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
             try {
                 recursionTypes.push(type);
                 let aliasName = (printTypeFlags & 4096 /* PrintTypeFlags.UseFullyQualifiedNames */) !== 0
-                    ? type.typeAliasInfo.fullName
-                    : type.typeAliasInfo.name;
+                    ? aliasInfo.fullName
+                    : aliasInfo.name;
                 // Use the fully-qualified name if the name isn't unique.
                 if (!uniqueNameMap.isUnique(aliasName)) {
-                    aliasName = type.typeAliasInfo.fullName;
+                    aliasName = aliasInfo.fullName;
                 }
-                const typeParams = type.typeAliasInfo.typeParameters;
+                const typeParams = aliasInfo.typeParameters;
                 if (typeParams && typeParams.length > 0) {
                     let argumentStrings;
                     // If there is a type arguments array, it's a specialized type alias.
-                    if (type.typeAliasInfo.typeArguments) {
+                    if (aliasInfo.typeArguments) {
                         if ((printTypeFlags & 2 /* PrintTypeFlags.OmitTypeArgumentsIfUnknown */) === 0 ||
-                            type.typeAliasInfo.typeArguments.some((typeArg) => !(0, types_1.isUnknown)(typeArg))) {
+                            aliasInfo.typeArguments.some((typeArg) => !(0, types_1.isUnknown)(typeArg))) {
                             argumentStrings = [];
-                            type.typeAliasInfo.typeArguments.forEach((typeArg, index) => {
+                            aliasInfo.typeArguments.forEach((typeArg, index) => {
                                 // Which type parameter does this map to?
                                 const typeParam = index < typeParams.length ? typeParams[index] : typeParams[typeParams.length - 1];
                                 // If this type argument maps to a variadic type parameter, unpack it.
                                 if ((0, types_1.isVariadicTypeVar)(typeParam) &&
                                     (0, types_1.isClassInstance)(typeArg) &&
                                     (0, typeUtils_1.isTupleClass)(typeArg) &&
-                                    typeArg.tupleTypeArguments &&
-                                    typeArg.tupleTypeArguments.every((typeArg) => !typeArg.isUnbounded)) {
-                                    typeArg.tupleTypeArguments.forEach((tupleTypeArg) => {
+                                    typeArg.priv.tupleTypeArguments &&
+                                    typeArg.priv.tupleTypeArguments.every((typeArg) => !typeArg.isUnbounded)) {
+                                    typeArg.priv.tupleTypeArguments.forEach((tupleTypeArg) => {
                                         argumentStrings.push(printTypeInternal(tupleTypeArg.type, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount));
                                     });
                                 }
@@ -263,24 +265,20 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
             }
         }
     }
-    if (recursionTypes.find((t) => {
-        var _a;
-        return t === type ||
-            (t.typeAliasInfo !== undefined && t.typeAliasInfo.fullName === ((_a = type.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.fullName));
-    }) ||
+    if (recursionTypes.find((t) => { var _a; return t === type || (!!((_a = t.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo) && t.props.typeAliasInfo.fullName === (aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.fullName)); }) ||
         recursionTypes.length > types_1.maxTypeRecursionCount) {
         // If this is a recursive TypeVar, we've already expanded it once, so
         // just print its name at this point.
-        if ((0, types_1.isTypeVar)(type) && type.details.isSynthesized && type.details.recursiveTypeAliasName) {
-            return type.details.recursiveTypeAliasName;
+        if ((0, types_1.isTypeVar)(type) && type.shared.isSynthesized && type.shared.recursiveAlias) {
+            return type.shared.recursiveAlias.name;
         }
-        if (type.typeAliasInfo) {
-            if (!type.typeAliasInfo.typeParameters) {
+        if (aliasInfo) {
+            if (!aliasInfo.typeParameters) {
                 let name = (printTypeFlags & 4096 /* PrintTypeFlags.UseFullyQualifiedNames */) !== 0
-                    ? type.typeAliasInfo.fullName
-                    : type.typeAliasInfo.name;
+                    ? aliasInfo.fullName
+                    : aliasInfo.name;
                 if (!uniqueNameMap.isUnique(name)) {
-                    name = type.typeAliasInfo.fullName;
+                    name = aliasInfo.fullName;
                 }
                 return name;
             }
@@ -298,7 +296,8 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
         recursionTypes.push(type);
         const includeConditionalIndicator = (printTypeFlags & (64 /* PrintTypeFlags.OmitConditionalConstraint */ | 256 /* PrintTypeFlags.PythonSyntax */)) === 0;
         const getConditionalIndicator = (subtype) => {
-            return subtype.condition !== undefined && includeConditionalIndicator ? '*' : '';
+            var _a;
+            return !!((_a = subtype.props) === null || _a === void 0 ? void 0 : _a.condition) && includeConditionalIndicator ? '*' : '';
         };
         switch (type.category) {
             case 0 /* TypeCategory.Unbound */: {
@@ -317,11 +316,11 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
                 if (printTypeFlags & 256 /* PrintTypeFlags.PythonSyntax */) {
                     return 'Any';
                 }
-                return `Module("${type.moduleName}")`;
+                return `Module("${type.priv.moduleName}")`;
             }
             case 6 /* TypeCategory.Class */: {
                 if (types_1.TypeBase.isInstance(type)) {
-                    if (type.literalValue !== undefined) {
+                    if (type.priv.literalValue !== undefined) {
                         if (isLiteralValueTruncated(type) && (printTypeFlags & 256 /* PrintTypeFlags.PythonSyntax */) !== 0) {
                             return printLiteralValueTruncated(type);
                         }
@@ -333,7 +332,7 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
                 }
                 else {
                     let typeToWrap;
-                    if (type.literalValue !== undefined) {
+                    if (type.priv.literalValue !== undefined) {
                         if (isLiteralValueTruncated(type) && (printTypeFlags & 256 /* PrintTypeFlags.PythonSyntax */) !== 0) {
                             typeToWrap = printLiteralValueTruncated(type);
                         }
@@ -342,8 +341,8 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
                         }
                     }
                     else {
-                        if (type.specialForm) {
-                            return printTypeInternal(type.specialForm, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
+                        if ((_b = type.props) === null || _b === void 0 ? void 0 : _b.specialForm) {
+                            return printTypeInternal(type.props.specialForm, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
                         }
                         typeToWrap = printObjectTypeForClassInternal(type, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
                     }
@@ -370,8 +369,8 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
             case 8 /* TypeCategory.Union */: {
                 // If this is a value expression that evaluates to a union type but is
                 // not a type alias, simply print the special form ("UnionType").
-                if (types_1.TypeBase.isInstantiable(type) && type.specialForm && !type.typeAliasInfo) {
-                    return printTypeInternal(type.specialForm, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
+                if (types_1.TypeBase.isInstantiable(type) && ((_c = type.props) === null || _c === void 0 ? void 0 : _c.specialForm) && !aliasInfo) {
+                    return printTypeInternal(type.props.specialForm, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
                 }
                 // Allocate a set that refers to subtypes in the union by
                 // their indices. If the index is within the set, it is already
@@ -385,16 +384,16 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
                     ? printTypeFlags | 128 /* PrintTypeFlags.ParenthesizeCallable */
                     : printTypeFlags;
                 // Start by matching possible type aliases to the subtypes.
-                if ((printTypeFlags & 32 /* PrintTypeFlags.ExpandTypeAlias */) === 0 && type.typeAliasSources) {
-                    for (const typeAliasSource of type.typeAliasSources) {
+                if ((printTypeFlags & 32 /* PrintTypeFlags.ExpandTypeAlias */) === 0 && type.priv.typeAliasSources) {
+                    for (const typeAliasSource of type.priv.typeAliasSources) {
                         let matchedAllSubtypes = true;
                         let allSubtypesPreviouslyHandled = true;
                         const indicesCoveredByTypeAlias = new Set();
-                        for (const sourceSubtype of typeAliasSource.subtypes) {
+                        for (const sourceSubtype of typeAliasSource.priv.subtypes) {
                             let unionSubtypeIndex = 0;
                             let foundMatch = false;
                             const sourceSubtypeInstance = (0, typeUtils_1.convertToInstance)(sourceSubtype);
-                            for (const unionSubtype of type.subtypes) {
+                            for (const unionSubtype of type.priv.subtypes) {
                                 if ((0, types_1.isTypeSame)(sourceSubtypeInstance, unionSubtype)) {
                                     if (!subtypeHandledSet.has(unionSubtypeIndex)) {
                                         allSubtypesPreviouslyHandled = false;
@@ -416,7 +415,7 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
                         }
                     }
                 }
-                const noneIndex = type.subtypes.findIndex((subtype) => (0, typeUtils_1.isNoneInstance)(subtype));
+                const noneIndex = type.priv.subtypes.findIndex((subtype) => (0, typeUtils_1.isNoneInstance)(subtype));
                 if (noneIndex >= 0 && !subtypeHandledSet.has(noneIndex)) {
                     const typeWithoutNone = (0, typeUtils_1.removeNoneFromUnion)(type);
                     if ((0, types_1.isNever)(typeWithoutNone)) {
@@ -436,7 +435,7 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
                 const literalClassStrings = new Set();
                 (0, typeUtils_1.doForEachSubtype)(type, (subtype, index) => {
                     if (!subtypeHandledSet.has(index)) {
-                        if ((0, types_1.isClassInstance)(subtype) && subtype.literalValue !== undefined) {
+                        if ((0, types_1.isClassInstance)(subtype) && subtype.priv.literalValue !== undefined) {
                             if (isLiteralValueTruncated(subtype) &&
                                 (printTypeFlags & 256 /* PrintTypeFlags.PythonSyntax */) !== 0) {
                                 subtypeStrings.add(printLiteralValueTruncated(subtype));
@@ -445,7 +444,7 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
                                 literalObjectStrings.add(printLiteralValue(subtype));
                             }
                         }
-                        else if ((0, types_1.isInstantiableClass)(subtype) && subtype.literalValue !== undefined) {
+                        else if ((0, types_1.isInstantiableClass)(subtype) && subtype.priv.literalValue !== undefined) {
                             if (isLiteralValueTruncated(subtype) &&
                                 (printTypeFlags & 256 /* PrintTypeFlags.PythonSyntax */) !== 0) {
                                 subtypeStrings.add(`type[${printLiteralValueTruncated(subtype)}]`);
@@ -488,23 +487,23 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
                 // This will confuse users. The exception is if it's a bound synthesized
                 // type, in which case we'll print the bound type. This is used for
                 // "self" and "cls" parameters.
-                if (type.details.isSynthesized) {
+                if (type.shared.isSynthesized) {
                     // If it's a synthesized type var used to implement recursive type
                     // aliases, return the type alias name.
-                    if (type.details.recursiveTypeAliasName) {
-                        if ((printTypeFlags & 32 /* PrintTypeFlags.ExpandTypeAlias */) !== 0 && type.details.boundType) {
+                    if (type.shared.recursiveAlias) {
+                        if ((printTypeFlags & 32 /* PrintTypeFlags.ExpandTypeAlias */) !== 0 && type.shared.boundType) {
                             return printTypeInternal(types_1.TypeBase.isInstance(type)
-                                ? (0, typeUtils_1.convertToInstance)(type.details.boundType)
-                                : type.details.boundType, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
+                                ? (0, typeUtils_1.convertToInstance)(type.shared.boundType)
+                                : type.shared.boundType, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
                         }
-                        return type.details.recursiveTypeAliasName;
+                        return type.shared.recursiveAlias.name;
                     }
                     // If it's a synthesized type var used to implement `self` or `cls` types,
                     // print the type with a special character that indicates that the type
                     // is internally represented as a TypeVar.
-                    if (type.details.isSynthesizedSelf && type.details.boundType) {
-                        let boundTypeString = printTypeInternal(type.details.boundType, printTypeFlags & ~32 /* PrintTypeFlags.ExpandTypeAlias */, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
-                        if (!(0, types_1.isAnyOrUnknown)(type.details.boundType)) {
+                    if (type.shared.isSynthesizedSelf && type.shared.boundType) {
+                        let boundTypeString = printTypeInternal(type.shared.boundType, printTypeFlags & ~32 /* PrintTypeFlags.ExpandTypeAlias */, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
+                        if (!(0, types_1.isAnyOrUnknown)(type.shared.boundType)) {
                             if (printTypeFlags & 256 /* PrintTypeFlags.PythonSyntax */) {
                                 boundTypeString = `Self`;
                             }
@@ -521,24 +520,24 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
                         ? 'Any'
                         : 'Unknown';
                 }
-                if (type.details.isParamSpec) {
+                if (type.shared.isParamSpec) {
                     const paramSpecText = _getReadableTypeVarName(type, (printTypeFlags & 256 /* PrintTypeFlags.PythonSyntax */) !== 0);
-                    if (type.paramSpecAccess) {
-                        return `${paramSpecText}.${type.paramSpecAccess}`;
+                    if (type.priv.paramSpecAccess) {
+                        return `${paramSpecText}.${type.priv.paramSpecAccess}`;
                     }
                     return paramSpecText;
                 }
                 let typeVarName = _getReadableTypeVarName(type, (printTypeFlags & 256 /* PrintTypeFlags.PythonSyntax */) !== 0);
-                if (type.isVariadicUnpacked) {
+                if (type.priv.isVariadicUnpacked) {
                     typeVarName = _printUnpack(typeVarName, printTypeFlags);
                 }
-                if (type.isVariadicInUnion) {
+                if (type.priv.isVariadicInUnion) {
                     typeVarName = `Union[${typeVarName}]`;
                 }
                 if (types_1.TypeBase.isInstantiable(type)) {
                     typeVarName = `${_printNestedInstantiable(type, typeVarName)}`;
                 }
-                if (!type.details.isVariadic && (printTypeFlags & 2048 /* PrintTypeFlags.PrintTypeVarVariance */) !== 0) {
+                if (!type.shared.isVariadic && (printTypeFlags & 2048 /* PrintTypeFlags.PrintTypeVarVariance */) !== 0) {
                     const varianceText = _getTypeVarVarianceText(type);
                     if (varianceText) {
                         typeVarName = `${typeVarName} (${varianceText})`;
@@ -547,11 +546,11 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
                 return typeVarName;
             }
             case 3 /* TypeCategory.Never */: {
-                return type.isNoReturn ? 'NoReturn' : 'Never';
+                return type.priv.isNoReturn ? 'NoReturn' : 'Never';
             }
             case 2 /* TypeCategory.Any */: {
                 const anyType = type;
-                return anyType.isEllipsis ? '...' : 'Any';
+                return anyType.priv.isEllipsis ? '...' : 'Any';
             }
         }
         return '';
@@ -566,12 +565,12 @@ function printFunctionType(type, printTypeFlags, returnTypeCallback, uniqueNameM
         const typeWithoutParamSpec = paramSpec ? types_1.FunctionType.cloneRemoveParamSpecArgsKwargs(type) : type;
         // Callable works only in cases where all parameters are positional-only.
         let isPositionalParamsOnly = false;
-        if (typeWithoutParamSpec.details.parameters.length === 0) {
+        if (typeWithoutParamSpec.shared.parameters.length === 0) {
             isPositionalParamsOnly = true;
         }
         else {
-            if (typeWithoutParamSpec.details.parameters.every((param) => param.category === 0 /* ParameterCategory.Simple */)) {
-                const lastParam = typeWithoutParamSpec.details.parameters[typeWithoutParamSpec.details.parameters.length - 1];
+            if (typeWithoutParamSpec.shared.parameters.every((param) => param.category === 0 /* ParameterCategory.Simple */)) {
+                const lastParam = typeWithoutParamSpec.shared.parameters[typeWithoutParamSpec.shared.parameters.length - 1];
                 if (!lastParam.name) {
                     isPositionalParamsOnly = true;
                 }
@@ -584,7 +583,7 @@ function printFunctionType(type, printTypeFlags, returnTypeCallback, uniqueNameM
         }
         if (isPositionalParamsOnly) {
             const paramTypes = [];
-            typeWithoutParamSpec.details.parameters.forEach((param, index) => {
+            typeWithoutParamSpec.shared.parameters.forEach((param, index) => {
                 if (param.name) {
                     const paramType = types_1.FunctionType.getEffectiveParameterType(typeWithoutParamSpec, index);
                     if (recursionTypes.length < types_1.maxTypeRecursionCount) {
@@ -597,9 +596,9 @@ function printFunctionType(type, printTypeFlags, returnTypeCallback, uniqueNameM
             });
             if (paramSpec) {
                 if (paramTypes.length > 0) {
-                    return `Callable[Concatenate[${paramTypes.join(', ')}, ${paramSpec.details.name}], ${returnTypeString}]`;
+                    return `Callable[Concatenate[${paramTypes.join(', ')}, ${paramSpec.shared.name}], ${returnTypeString}]`;
                 }
-                return `Callable[${paramSpec.details.name}, ${returnTypeString}]`;
+                return `Callable[${paramSpec.shared.name}, ${returnTypeString}]`;
             }
             return `Callable[[${paramTypes.join(', ')}], ${returnTypeString}]`;
         }
@@ -628,10 +627,10 @@ function printFunctionType(type, printTypeFlags, returnTypeCallback, uniqueNameM
 }
 function printObjectTypeForClassInternal(type, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount) {
     var _a, _b;
-    let objName = type.aliasName;
+    let objName = type.priv.aliasName;
     if (!objName) {
         objName =
-            (printTypeFlags & 4096 /* PrintTypeFlags.UseFullyQualifiedNames */) !== 0 ? type.details.fullName : type.details.name;
+            (printTypeFlags & 4096 /* PrintTypeFlags.UseFullyQualifiedNames */) !== 0 ? type.shared.fullName : type.shared.name;
     }
     // Special-case NoneType to convert it to None.
     if (types_1.ClassType.isBuiltIn(type, 'NoneType')) {
@@ -639,16 +638,16 @@ function printObjectTypeForClassInternal(type, printTypeFlags, returnTypeCallbac
     }
     // Use the fully-qualified name if the name isn't unique.
     if (!uniqueNameMap.isUnique(objName)) {
-        objName = type.details.fullName;
+        objName = type.shared.fullName;
     }
     // If this is a pseudo-generic class, don't display the type arguments
     // or type parameters because it will confuse users.
     if (!types_1.ClassType.isPseudoGenericClass(type)) {
         const typeParams = types_1.ClassType.getTypeParameters(type);
         const lastTypeParam = typeParams.length > 0 ? typeParams[typeParams.length - 1] : undefined;
-        const isVariadic = lastTypeParam ? lastTypeParam.details.isVariadic : false;
+        const isVariadic = lastTypeParam ? lastTypeParam.shared.isVariadic : false;
         // If there is a type arguments array, it's a specialized class.
-        const typeArgs = (_a = type.tupleTypeArguments) !== null && _a !== void 0 ? _a : (_b = type.typeArguments) === null || _b === void 0 ? void 0 : _b.map((t) => {
+        const typeArgs = (_a = type.priv.tupleTypeArguments) !== null && _a !== void 0 ? _a : (_b = type.priv.typeArguments) === null || _b === void 0 ? void 0 : _b.map((t) => {
             return { type: t, isUnbounded: false };
         });
         if (typeArgs) {
@@ -659,12 +658,12 @@ function printObjectTypeForClassInternal(type, printTypeFlags, returnTypeCallbac
                 typeArgs.forEach((typeArg, index) => {
                     const typeParam = index < typeParams.length ? typeParams[index] : undefined;
                     if (typeParam &&
-                        typeParam.details.isVariadic &&
+                        typeParam.shared.isVariadic &&
                         (0, types_1.isClassInstance)(typeArg.type) &&
                         types_1.ClassType.isBuiltIn(typeArg.type, 'tuple') &&
-                        typeArg.type.tupleTypeArguments) {
+                        typeArg.type.priv.tupleTypeArguments) {
                         // Expand the tuple type that maps to the variadic type parameter.
-                        if (typeArg.type.tupleTypeArguments.length === 0) {
+                        if (typeArg.type.priv.tupleTypeArguments.length === 0) {
                             if (!(0, types_1.isUnknown)(typeArg.type)) {
                                 isAllUnknown = false;
                             }
@@ -673,7 +672,7 @@ function printObjectTypeForClassInternal(type, printTypeFlags, returnTypeCallbac
                             }
                         }
                         else {
-                            (0, collectionUtils_1.appendArray)(typeArgStrings, typeArg.type.tupleTypeArguments.map((typeArg) => {
+                            (0, collectionUtils_1.appendArray)(typeArgStrings, typeArg.type.priv.tupleTypeArguments.map((typeArg) => {
                                 if (!(0, types_1.isUnknown)(typeArg.type)) {
                                     isAllUnknown = false;
                                 }
@@ -703,7 +702,7 @@ function printObjectTypeForClassInternal(type, printTypeFlags, returnTypeCallbac
                         }
                     }
                 });
-                if (type.isUnpacked) {
+                if (type.priv.isUnpacked) {
                     objName = _printUnpack(objName, printTypeFlags);
                 }
                 if ((printTypeFlags & 2 /* PrintTypeFlags.OmitTypeArgumentsIfUnknown */) === 0 || !isAllUnknown) {
@@ -711,7 +710,7 @@ function printObjectTypeForClassInternal(type, printTypeFlags, returnTypeCallbac
                 }
             }
             else {
-                if (type.isUnpacked) {
+                if (type.priv.isUnpacked) {
                     objName = _printUnpack(objName, printTypeFlags);
                 }
                 if (types_1.ClassType.isTupleClass(type) || isVariadic) {
@@ -720,7 +719,7 @@ function printObjectTypeForClassInternal(type, printTypeFlags, returnTypeCallbac
             }
         }
         else {
-            if (type.isUnpacked) {
+            if (type.priv.isUnpacked) {
                 objName = _printUnpack(objName, printTypeFlags);
             }
             if (typeParams.length > 0) {
@@ -739,7 +738,7 @@ function printObjectTypeForClassInternal(type, printTypeFlags, returnTypeCallbac
         }
     }
     // Wrap in a "Partial" for TypedDict that has been synthesized as partial.
-    if (type.isTypedDictPartial) {
+    if (type.priv.isTypedDictPartial) {
         if ((printTypeFlags & 256 /* PrintTypeFlags.PythonSyntax */) === 0) {
             objName = `Partial[${objName}]`;
         }
@@ -747,23 +746,25 @@ function printObjectTypeForClassInternal(type, printTypeFlags, returnTypeCallbac
     return objName;
 }
 function printFunctionPartsInternal(type, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount) {
+    var _a;
     const paramTypeStrings = [];
     let sawDefinedName = false;
+    const functionNode = (_a = type.shared.declaration) === null || _a === void 0 ? void 0 : _a.node;
     // Remove the (*args: P.args, **kwargs: P.kwargs) from the end of the parameter list.
     const paramSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(type);
     if (paramSpec) {
         type = types_1.FunctionType.cloneRemoveParamSpecArgsKwargs(type);
     }
-    type.details.parameters.forEach((param, index) => {
+    type.shared.parameters.forEach((param, index) => {
         // Handle specialized variadic type parameters specially.
-        if (index === type.details.parameters.length - 1 &&
+        if (index === type.shared.parameters.length - 1 &&
             param.category === 1 /* ParameterCategory.ArgsList */ &&
             (0, types_1.isVariadicTypeVar)(param.type)) {
             const specializedParamType = types_1.FunctionType.getEffectiveParameterType(type, index);
             if ((0, types_1.isClassInstance)(specializedParamType) &&
                 types_1.ClassType.isBuiltIn(specializedParamType, 'tuple') &&
-                specializedParamType.tupleTypeArguments) {
-                specializedParamType.tupleTypeArguments.forEach((paramType) => {
+                specializedParamType.priv.tupleTypeArguments) {
+                specializedParamType.priv.tupleTypeArguments.forEach((paramType) => {
                     const paramString = printTypeInternal(paramType.type, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
                     paramTypeStrings.push(paramString);
                 });
@@ -774,7 +775,7 @@ function printFunctionPartsInternal(type, printTypeFlags, returnTypeCallback, un
         if ((0, parameterUtils_1.isTypedKwargs)(param) &&
             printTypeFlags & 1024 /* PrintTypeFlags.ExpandTypedDictArgs */ &&
             param.type.category === 6 /* TypeCategory.Class */) {
-            param.type.details.typedDictEntries.knownItems.forEach((v, k) => {
+            param.type.shared.typedDictEntries.knownItems.forEach((v, k) => {
                 const valueTypeString = printTypeInternal(v.valueType, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
                 paramTypeStrings.push(`${k}: ${valueTypeString}`);
             });
@@ -782,7 +783,7 @@ function printFunctionPartsInternal(type, printTypeFlags, returnTypeCallback, un
         }
         let paramString = '';
         if (param.category === 1 /* ParameterCategory.ArgsList */) {
-            if (!param.name || !param.isNameSynthesized) {
+            if (!param.name || !types_1.FunctionParam.isNameSynthesized(param)) {
                 paramString += '*';
             }
         }
@@ -790,7 +791,7 @@ function printFunctionPartsInternal(type, printTypeFlags, returnTypeCallback, un
             paramString += '**';
         }
         let emittedParamName = false;
-        if (param.name && !param.isNameSynthesized) {
+        if (param.name && !types_1.FunctionParam.isNameSynthesized(param)) {
             paramString += param.name;
             sawDefinedName = true;
             emittedParamName = true;
@@ -804,7 +805,7 @@ function printFunctionPartsInternal(type, printTypeFlags, returnTypeCallback, un
         let isParamSpecArgsKwargsParam = false;
         if (param.name) {
             // Avoid printing type types if parameter have unknown type.
-            if (param.hasDeclaredType || param.isTypeInferred) {
+            if (types_1.FunctionParam.isTypeDeclared(param) || types_1.FunctionParam.isTypeInferred(param)) {
                 const paramType = types_1.FunctionType.getEffectiveParameterType(type, index);
                 let paramTypeString = recursionTypes.length < types_1.maxTypeRecursionCount
                     ? printTypeInternal(paramType, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount)
@@ -837,7 +838,7 @@ function printFunctionPartsInternal(type, printTypeFlags, returnTypeCallback, un
                 defaultValueAssignment = ' = ';
             }
             else if ((printTypeFlags & 2 /* PrintTypeFlags.OmitTypeArgumentsIfUnknown */) === 0) {
-                if (!param.isNameSynthesized) {
+                if (!types_1.FunctionParam.isNameSynthesized(param)) {
                     paramString += ': ';
                 }
                 if (printTypeFlags & (1 /* PrintTypeFlags.PrintUnknownWithAny */ | 256 /* PrintTypeFlags.PythonSyntax */)) {
@@ -857,9 +858,10 @@ function printFunctionPartsInternal(type, printTypeFlags, returnTypeCallback, un
                 return;
             }
         }
-        if (param.hasDefault) {
-            if (param.defaultValueExpression) {
-                paramString += defaultValueAssignment + ParseTreeUtils.printExpression(param.defaultValueExpression);
+        if (param.defaultType) {
+            const paramNode = functionNode === null || functionNode === void 0 ? void 0 : functionNode.d.params.find((p) => { var _a; return ((_a = p.d.name) === null || _a === void 0 ? void 0 : _a.d.value) === param.name; });
+            if (paramNode === null || paramNode === void 0 ? void 0 : paramNode.d.defaultValue) {
+                paramString += defaultValueAssignment + ParseTreeUtils.printExpression(paramNode.d.defaultValue);
             }
             else {
                 // If the function doesn't originate from a function declaration (e.g. it is
@@ -900,8 +902,8 @@ function _printUnpack(textToWrap, flags) {
 // Surrounds a printed type with Type[...] as many times as needed
 // for the nested instantiable count.
 function _printNestedInstantiable(type, textToWrap) {
-    var _a;
-    const nestedTypes = ((_a = type.instantiableNestingLevel) !== null && _a !== void 0 ? _a : 0) + 1;
+    var _a, _b;
+    const nestedTypes = ((_b = (_a = type.props) === null || _a === void 0 ? void 0 : _a.instantiableDepth) !== null && _b !== void 0 ? _b : 0) + 1;
     for (let nestLevel = 0; nestLevel < nestedTypes; nestLevel++) {
         textToWrap = `type[${textToWrap}]`;
     }
@@ -909,13 +911,13 @@ function _printNestedInstantiable(type, textToWrap) {
 }
 function _getReadableTypeVarName(type, usePythonSyntax) {
     if (usePythonSyntax) {
-        return type.details.name;
+        return type.shared.name;
     }
     return types_1.TypeVarType.getReadableName(type);
 }
 function _getTypeVarVarianceText(type) {
     var _a;
-    const computedVariance = (_a = type.computedVariance) !== null && _a !== void 0 ? _a : type.details.declaredVariance;
+    const computedVariance = (_a = type.priv.computedVariance) !== null && _a !== void 0 ? _a : type.shared.declaredVariance;
     if (computedVariance === 2 /* Variance.Invariant */) {
         return 'invariant';
     }
@@ -937,12 +939,13 @@ class UniqueNameMap {
         this._map = new Map();
     }
     build(type, recursionTypes = [], recursionCount = 0) {
-        var _a;
+        var _a, _b;
         if (recursionCount > types_1.maxTypeRecursionCount) {
             return;
         }
         recursionCount++;
-        if (type.typeAliasInfo) {
+        const aliasInfo = (_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo;
+        if (aliasInfo) {
             let expandTypeAlias = true;
             if ((this._printTypeFlags & 32 /* PrintTypeFlags.ExpandTypeAlias */) === 0) {
                 expandTypeAlias = false;
@@ -954,14 +957,14 @@ class UniqueNameMap {
             }
             if (!expandTypeAlias) {
                 const typeAliasName = (this._printTypeFlags & 4096 /* PrintTypeFlags.UseFullyQualifiedNames */) !== 0
-                    ? type.typeAliasInfo.fullName
-                    : type.typeAliasInfo.name;
+                    ? aliasInfo.fullName
+                    : aliasInfo.name;
                 this._addIfUnique(typeAliasName, type, /* useTypeAliasName */ true);
                 // Recursively add the type arguments if present.
-                if (type.typeAliasInfo.typeArguments) {
+                if (aliasInfo.typeArguments) {
                     recursionTypes.push(type);
                     try {
-                        type.typeAliasInfo.typeArguments.forEach((typeArg) => {
+                        aliasInfo.typeArguments.forEach((typeArg) => {
                             this.build(typeArg, recursionTypes, recursionCount);
                         });
                     }
@@ -976,7 +979,7 @@ class UniqueNameMap {
             recursionTypes.push(type);
             switch (type.category) {
                 case 4 /* TypeCategory.Function */: {
-                    type.details.parameters.forEach((_, index) => {
+                    type.shared.parameters.forEach((_, index) => {
                         const paramType = types_1.FunctionType.getEffectiveParameterType(type, index);
                         this.build(paramType, recursionTypes, recursionCount);
                     });
@@ -985,31 +988,31 @@ class UniqueNameMap {
                     break;
                 }
                 case 5 /* TypeCategory.OverloadedFunction */: {
-                    type.overloads.forEach((overload) => {
+                    type.priv.overloads.forEach((overload) => {
                         this.build(overload, recursionTypes, recursionCount);
                     });
                     break;
                 }
                 case 6 /* TypeCategory.Class */: {
-                    if (type.literalValue !== undefined) {
+                    if (type.priv.literalValue !== undefined) {
                         break;
                     }
-                    let className = type.aliasName;
+                    let className = type.priv.aliasName;
                     if (!className) {
                         className =
                             (this._printTypeFlags & 4096 /* PrintTypeFlags.UseFullyQualifiedNames */) !== 0
-                                ? type.details.fullName
-                                : type.details.name;
+                                ? type.shared.fullName
+                                : type.shared.name;
                     }
                     this._addIfUnique(className, type);
                     if (!types_1.ClassType.isPseudoGenericClass(type)) {
-                        if (type.tupleTypeArguments) {
-                            type.tupleTypeArguments.forEach((typeArg) => {
+                        if (type.priv.tupleTypeArguments) {
+                            type.priv.tupleTypeArguments.forEach((typeArg) => {
                                 this.build(typeArg.type, recursionTypes, recursionCount);
                             });
                         }
-                        else if (type.typeArguments) {
-                            type.typeArguments.forEach((typeArg) => {
+                        else if (type.priv.typeArguments) {
+                            type.priv.typeArguments.forEach((typeArg) => {
                                 this.build(typeArg, recursionTypes, recursionCount);
                             });
                         }
@@ -1020,7 +1023,7 @@ class UniqueNameMap {
                     (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
                         this.build(subtype, recursionTypes, recursionCount);
                     });
-                    (_a = type.typeAliasSources) === null || _a === void 0 ? void 0 : _a.forEach((typeAliasSource) => {
+                    (_b = type.priv.typeAliasSources) === null || _b === void 0 ? void 0 : _b.forEach((typeAliasSource) => {
                         this.build(typeAliasSource, recursionTypes, recursionCount);
                     });
                     break;
@@ -1047,9 +1050,9 @@ class UniqueNameMap {
         }
     }
     _isSameTypeName(type1, type2, useTypeAliasName) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         if (useTypeAliasName) {
-            return ((_a = type1.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.fullName) === ((_b = type2.typeAliasInfo) === null || _b === void 0 ? void 0 : _b.fullName);
+            return ((_b = (_a = type1.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo) === null || _b === void 0 ? void 0 : _b.fullName) === ((_d = (_c = type2.props) === null || _c === void 0 ? void 0 : _c.typeAliasInfo) === null || _d === void 0 ? void 0 : _d.fullName);
         }
         if ((0, types_1.isClass)(type1) && (0, types_1.isClass)(type2)) {
             return types_1.ClassType.isSameGenericClass(type1, type2);