@zzzen/pyright-internal 1.2.0-dev.20231119 → 1.2.0-dev.20231203

package/dist/analyzer/typePrinter.js

@@ -9,7 +9,11 @@
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -68,7 +72,7 @@ var PrintTypeFlags;
     // Use the fully-qualified name of classes, type aliases, modules,
     // and functions rather than short names.
     PrintTypeFlags[PrintTypeFlags["UseFullyQualifiedNames"] = 4096] = "UseFullyQualifiedNames";
-})(PrintTypeFlags = exports.PrintTypeFlags || (exports.PrintTypeFlags = {}));
+})(PrintTypeFlags || (exports.PrintTypeFlags = PrintTypeFlags = {}));
 function printType(type, printTypeFlags, returnTypeCallback) {
     const uniqueNameMap = new UniqueNameMap(printTypeFlags, returnTypeCallback);
     uniqueNameMap.build(type);
@@ -154,10 +158,10 @@ function printLiteralValue(type, quotation = "'") {
 exports.printLiteralValue = printLiteralValue;
 function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount) {
     const originalPrintTypeFlags = printTypeFlags;
-    const parenthesizeUnion = (printTypeFlags & 16 /* ParenthesizeUnion */) !== 0;
-    printTypeFlags &= ~(16 /* ParenthesizeUnion */ | 128 /* ParenthesizeCallable */);
+    const parenthesizeUnion = (printTypeFlags & 16 /* PrintTypeFlags.ParenthesizeUnion */) !== 0;
+    printTypeFlags &= ~(16 /* PrintTypeFlags.ParenthesizeUnion */ | 128 /* PrintTypeFlags.ParenthesizeCallable */);
     if (recursionCount > types_1.maxTypeRecursionCount) {
-        if (printTypeFlags & 256 /* PythonSyntax */) {
+        if (printTypeFlags & 256 /* PrintTypeFlags.PythonSyntax */) {
             return 'Any';
         }
         return '<Recursive>';
@@ -167,7 +171,7 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
     // the type it represents.
     if (type.typeAliasInfo) {
         let expandTypeAlias = true;
-        if ((printTypeFlags & 32 /* ExpandTypeAlias */) === 0) {
+        if ((printTypeFlags & 32 /* PrintTypeFlags.ExpandTypeAlias */) === 0) {
             expandTypeAlias = false;
         }
         else {
@@ -178,7 +182,7 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
         if (!expandTypeAlias) {
             try {
                 recursionTypes.push(type);
-                let aliasName = (printTypeFlags & 4096 /* UseFullyQualifiedNames */) !== 0
+                let aliasName = (printTypeFlags & 4096 /* PrintTypeFlags.UseFullyQualifiedNames */) !== 0
                     ? type.typeAliasInfo.fullName
                     : type.typeAliasInfo.name;
                 // Use the fully-qualified name if the name isn't unique.
@@ -190,7 +194,7 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
                     let argumentStrings;
                     // If there is a type arguments array, it's a specialized type alias.
                     if (type.typeAliasInfo.typeArguments) {
-                        if ((printTypeFlags & 2 /* OmitTypeArgumentsIfUnknown */) === 0 ||
+                        if ((printTypeFlags & 2 /* PrintTypeFlags.OmitTypeArgumentsIfUnknown */) === 0 ||
                             type.typeAliasInfo.typeArguments.some((typeArg) => !(0, types_1.isUnknown)(typeArg))) {
                             argumentStrings = [];
                             type.typeAliasInfo.typeArguments.forEach((typeArg, index) => {
@@ -212,7 +216,7 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
                         }
                     }
                     else {
-                        if ((printTypeFlags & 2 /* OmitTypeArgumentsIfUnknown */) === 0 ||
+                        if ((printTypeFlags & 2 /* PrintTypeFlags.OmitTypeArgumentsIfUnknown */) === 0 ||
                             typeParams.some((typeParam) => !(0, types_1.isUnknown)(typeParam))) {
                             argumentStrings = [];
                             typeParams.forEach((typeParam) => {
@@ -231,7 +235,7 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
                 }
                 // If it's a TypeVar, don't use the alias name. Instead, use the full
                 // name, which may have a scope associated with it.
-                if (type.category !== 9 /* TypeVar */) {
+                if (type.category !== 9 /* TypeCategory.TypeVar */) {
                     return aliasName;
                 }
             }
@@ -253,7 +257,7 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
         }
         if (type.typeAliasInfo) {
             if (!type.typeAliasInfo.typeParameters) {
-                let name = (printTypeFlags & 4096 /* UseFullyQualifiedNames */) !== 0
+                let name = (printTypeFlags & 4096 /* PrintTypeFlags.UseFullyQualifiedNames */) !== 0
                     ? type.typeAliasInfo.fullName
                     : type.typeAliasInfo.name;
                 if (!uniqueNameMap.isUnique(name)) {
@@ -263,7 +267,7 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
             }
             try {
                 recursionTypes.push(type);
-                return printTypeInternal(type, printTypeFlags & ~32 /* ExpandTypeAlias */, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
+                return printTypeInternal(type, printTypeFlags & ~32 /* PrintTypeFlags.ExpandTypeAlias */, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
             }
             finally {
                 recursionTypes.pop();
@@ -273,30 +277,30 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
     }
     try {
         recursionTypes.push(type);
-        const includeConditionalIndicator = (printTypeFlags & (64 /* OmitConditionalConstraint */ | 256 /* PythonSyntax */)) === 0;
+        const includeConditionalIndicator = (printTypeFlags & (64 /* PrintTypeFlags.OmitConditionalConstraint */ | 256 /* PrintTypeFlags.PythonSyntax */)) === 0;
         const getConditionalIndicator = (subtype) => {
             return subtype.condition !== undefined && includeConditionalIndicator ? '*' : '';
         };
         switch (type.category) {
-            case 0 /* Unbound */: {
-                if (printTypeFlags & 256 /* PythonSyntax */) {
+            case 0 /* TypeCategory.Unbound */: {
+                if (printTypeFlags & 256 /* PrintTypeFlags.PythonSyntax */) {
                     return 'Any';
                 }
                 return 'Unbound';
             }
-            case 1 /* Unknown */: {
-                if (printTypeFlags & (256 /* PythonSyntax */ | 1 /* PrintUnknownWithAny */)) {
+            case 1 /* TypeCategory.Unknown */: {
+                if (printTypeFlags & (256 /* PrintTypeFlags.PythonSyntax */ | 1 /* PrintTypeFlags.PrintUnknownWithAny */)) {
                     return 'Any';
                 }
                 return 'Unknown';
             }
-            case 7 /* Module */: {
-                if (printTypeFlags & 256 /* PythonSyntax */) {
+            case 7 /* TypeCategory.Module */: {
+                if (printTypeFlags & 256 /* PrintTypeFlags.PythonSyntax */) {
                     return 'Any';
                 }
                 return `Module("${type.moduleName}")`;
             }
-            case 6 /* Class */: {
+            case 6 /* TypeCategory.Class */: {
                 if (types_1.TypeBase.isInstance(type)) {
                     if (type.literalValue !== undefined) {
                         return `Literal[${printLiteralValue(type)}]`;
@@ -314,22 +318,22 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
                     return `${_printNestedInstantiable(type, typeToWrap)}${getConditionalIndicator(type)}`;
                 }
             }
-            case 4 /* Function */: {
+            case 4 /* TypeCategory.Function */: {
                 if (types_1.TypeBase.isInstantiable(type)) {
                     const typeString = printFunctionType(types_1.FunctionType.cloneAsInstance(type), printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
                     return `type[${typeString}]`;
                 }
                 return printFunctionType(type, originalPrintTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
             }
-            case 5 /* OverloadedFunction */: {
+            case 5 /* TypeCategory.OverloadedFunction */: {
                 const overloadedType = type;
                 const overloads = overloadedType.overloads.map((overload) => printTypeInternal(overload, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount));
-                if (printTypeFlags & 256 /* PythonSyntax */) {
+                if (printTypeFlags & 256 /* PrintTypeFlags.PythonSyntax */) {
                     return 'Callable[..., Any]';
                 }
                 return `Overload[${overloads.join(', ')}]`;
             }
-            case 8 /* Union */: {
+            case 8 /* TypeCategory.Union */: {
                 // Allocate a set that refers to subtypes in the union by
                 // their indices. If the index is within the set, it is already
                 // accounted for in the output.
@@ -338,11 +342,11 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
                 // of the subtypes in the union.
                 const subtypeStrings = new Set();
                 // If we're using "|" notation, enclose callable subtypes in parens.
-                const updatedPrintTypeFlags = printTypeFlags & 8 /* PEP604 */
-                    ? printTypeFlags | 128 /* ParenthesizeCallable */
+                const updatedPrintTypeFlags = printTypeFlags & 8 /* PrintTypeFlags.PEP604 */
+                    ? printTypeFlags | 128 /* PrintTypeFlags.ParenthesizeCallable */
                     : printTypeFlags;
                 // Start by matching possible type aliases to the subtypes.
-                if ((printTypeFlags & 32 /* ExpandTypeAlias */) === 0 && type.typeAliasSources) {
+                if ((printTypeFlags & 32 /* PrintTypeFlags.ExpandTypeAlias */) === 0 && type.typeAliasSources) {
                     for (const typeAliasSource of type.typeAliasSources) {
                         let matchedAllSubtypes = true;
                         let allSubtypesPreviouslyHandled = true;
@@ -353,7 +357,7 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
                             const sourceSubtypeInstance = (0, typeUtils_1.convertToInstance)(sourceSubtype);
                             for (const unionSubtype of type.subtypes) {
                                 if ((0, types_1.isTypeSame)(sourceSubtypeInstance, unionSubtype, {
-                                    typeFlagsToHonor: 2 /* Instance */ | 1 /* Instantiable */,
+                                    typeFlagsToHonor: 2 /* TypeFlags.Instance */ | 1 /* TypeFlags.Instantiable */,
                                 })) {
                                     if (!subtypeHandledSet.has(unionSubtypeIndex)) {
                                         allSubtypesPreviouslyHandled = false;
@@ -382,7 +386,7 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
                         return 'None';
                     }
                     const optionalType = printTypeInternal(typeWithoutNone, updatedPrintTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
-                    if (printTypeFlags & 8 /* PEP604 */) {
+                    if (printTypeFlags & 8 /* PrintTypeFlags.PEP604 */) {
                         const unionString = optionalType + ' | None';
                         if (parenthesizeUnion) {
                             return `(${unionString})`;
@@ -421,7 +425,7 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
                 if (dedupedSubtypeStrings.length === 1) {
                     return dedupedSubtypeStrings[0];
                 }
-                if (printTypeFlags & 8 /* PEP604 */) {
+                if (printTypeFlags & 8 /* PrintTypeFlags.PEP604 */) {
                     const unionString = dedupedSubtypeStrings.join(' | ');
                     if (parenthesizeUnion) {
                         return `(${unionString})`;
@@ -430,7 +434,7 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
                 }
                 return `Union[${dedupedSubtypeStrings.join(', ')}]`;
             }
-            case 9 /* TypeVar */: {
+            case 9 /* TypeCategory.TypeVar */: {
                 // If it's synthesized, don't expose the internal name we generated.
                 // 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
@@ -439,7 +443,7 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
                     // 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 /* ExpandTypeAlias */) !== 0 && type.details.boundType) {
+                        if ((printTypeFlags & 32 /* PrintTypeFlags.ExpandTypeAlias */) !== 0 && type.details.boundType) {
                             return printTypeInternal(types_1.TypeBase.isInstance(type)
                                 ? (0, typeUtils_1.convertToInstance)(type.details.boundType)
                                 : type.details.boundType, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
@@ -450,9 +454,9 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
                     // 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 /* ExpandTypeAlias */, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
+                        let boundTypeString = printTypeInternal(type.details.boundType, printTypeFlags & ~32 /* PrintTypeFlags.ExpandTypeAlias */, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
                         if (!(0, types_1.isAnyOrUnknown)(type.details.boundType)) {
-                            if (printTypeFlags & 256 /* PythonSyntax */) {
+                            if (printTypeFlags & 256 /* PrintTypeFlags.PythonSyntax */) {
                                 boundTypeString = `Self`;
                             }
                             else {
@@ -464,18 +468,18 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
                         }
                         return boundTypeString;
                     }
-                    return (printTypeFlags & (1 /* PrintUnknownWithAny */ | 256 /* PythonSyntax */)) !== 0
+                    return (printTypeFlags & (1 /* PrintTypeFlags.PrintUnknownWithAny */ | 256 /* PrintTypeFlags.PythonSyntax */)) !== 0
                         ? 'Any'
                         : 'Unknown';
                 }
                 if (type.details.isParamSpec) {
-                    const paramSpecText = _getReadableTypeVarName(type, (printTypeFlags & 256 /* PythonSyntax */) !== 0);
+                    const paramSpecText = _getReadableTypeVarName(type, (printTypeFlags & 256 /* PrintTypeFlags.PythonSyntax */) !== 0);
                     if (type.paramSpecAccess) {
                         return `${paramSpecText}.${type.paramSpecAccess}`;
                     }
                     return paramSpecText;
                 }
-                let typeVarName = _getReadableTypeVarName(type, (printTypeFlags & 256 /* PythonSyntax */) !== 0);
+                let typeVarName = _getReadableTypeVarName(type, (printTypeFlags & 256 /* PrintTypeFlags.PythonSyntax */) !== 0);
                 if (type.isVariadicUnpacked) {
                     typeVarName = _printUnpack(typeVarName, printTypeFlags);
                 }
@@ -485,7 +489,7 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
                 if (types_1.TypeBase.isInstantiable(type)) {
                     typeVarName = `${_printNestedInstantiable(type, typeVarName)}`;
                 }
-                if (!type.details.isVariadic && (printTypeFlags & 2048 /* PrintTypeVarVariance */) !== 0) {
+                if (!type.details.isVariadic && (printTypeFlags & 2048 /* PrintTypeFlags.PrintTypeVarVariance */) !== 0) {
                     const varianceText = _getTypeVarVarianceText(type);
                     if (varianceText) {
                         typeVarName = `${typeVarName} (${varianceText})`;
@@ -493,10 +497,10 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
                 }
                 return typeVarName;
             }
-            case 3 /* Never */: {
+            case 3 /* TypeCategory.Never */: {
                 return type.isNoReturn ? 'NoReturn' : 'Never';
             }
-            case 2 /* Any */: {
+            case 2 /* TypeCategory.Any */: {
                 const anyType = type;
                 return anyType.isEllipsis ? '...' : 'Any';
             }
@@ -508,14 +512,14 @@ function printTypeInternal(type, printTypeFlags, returnTypeCallback, uniqueNameM
     }
 }
 function printFunctionType(type, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount) {
-    if (printTypeFlags & 256 /* PythonSyntax */) {
+    if (printTypeFlags & 256 /* PrintTypeFlags.PythonSyntax */) {
         // Callable works only in cases where all parameters are positional-only.
         let isPositionalParamsOnly = false;
         if (type.details.parameters.length === 0) {
             isPositionalParamsOnly = true;
         }
         else {
-            if (type.details.parameters.every((param) => param.category === 0 /* Simple */)) {
+            if (type.details.parameters.every((param) => param.category === 0 /* ParameterCategory.Simple */)) {
                 const lastParam = type.details.parameters[type.details.parameters.length - 1];
                 if (!lastParam.name) {
                     isPositionalParamsOnly = true;
@@ -564,7 +568,7 @@ function printFunctionType(type, printTypeFlags, returnTypeCallback, uniqueNameM
             return paramSignature;
         }
         const fullSignature = `${paramSignature} -> ${parts[1]}`;
-        const parenthesizeCallable = (printTypeFlags & 128 /* ParenthesizeCallable */) !== 0;
+        const parenthesizeCallable = (printTypeFlags & 128 /* PrintTypeFlags.ParenthesizeCallable */) !== 0;
         if (parenthesizeCallable) {
             return `(${fullSignature})`;
         }
@@ -576,7 +580,7 @@ function printObjectTypeForClassInternal(type, printTypeFlags, returnTypeCallbac
     let objName = type.aliasName;
     if (!objName) {
         objName =
-            (printTypeFlags & 4096 /* UseFullyQualifiedNames */) !== 0 ? type.details.fullName : type.details.name;
+            (printTypeFlags & 4096 /* PrintTypeFlags.UseFullyQualifiedNames */) !== 0 ? type.details.fullName : type.details.name;
     }
     // Special-case NoneType to convert it to None.
     if (types_1.ClassType.isBuiltIn(type, 'NoneType')) {
@@ -651,7 +655,7 @@ function printObjectTypeForClassInternal(type, printTypeFlags, returnTypeCallbac
                 if (type.isUnpacked) {
                     objName = _printUnpack(objName, printTypeFlags);
                 }
-                if ((printTypeFlags & 2 /* OmitTypeArgumentsIfUnknown */) === 0 || !isAllUnknown) {
+                if ((printTypeFlags & 2 /* PrintTypeFlags.OmitTypeArgumentsIfUnknown */) === 0 || !isAllUnknown) {
                     objName += '[' + typeArgStrings.join(', ') + ']';
                 }
             }
@@ -669,7 +673,7 @@ function printObjectTypeForClassInternal(type, printTypeFlags, returnTypeCallbac
                 objName = _printUnpack(objName, printTypeFlags);
             }
             if (typeParams.length > 0) {
-                if ((printTypeFlags & 2 /* OmitTypeArgumentsIfUnknown */) === 0 ||
+                if ((printTypeFlags & 2 /* PrintTypeFlags.OmitTypeArgumentsIfUnknown */) === 0 ||
                     typeParams.some((typeParam) => !(0, types_1.isUnknown)(typeParam))) {
                     objName +=
                         '[' +
@@ -685,7 +689,7 @@ function printObjectTypeForClassInternal(type, printTypeFlags, returnTypeCallbac
     }
     // Wrap in a "Partial" for TypedDict that has been synthesized as partial.
     if (type.isTypedDictPartial) {
-        if ((printTypeFlags & 256 /* PythonSyntax */) === 0) {
+        if ((printTypeFlags & 256 /* PrintTypeFlags.PythonSyntax */) === 0) {
             objName = `Partial[${objName}]`;
         }
     }
@@ -697,7 +701,7 @@ function printFunctionPartsInternal(type, printTypeFlags, returnTypeCallback, un
     type.details.parameters.forEach((param, index) => {
         // Handle specialized variadic type parameters specially.
         if (index === type.details.parameters.length - 1 &&
-            param.category === 1 /* ArgsList */ &&
+            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) &&
@@ -712,8 +716,8 @@ function printFunctionPartsInternal(type, printTypeFlags, returnTypeCallback, un
         }
         // Handle expanding TypedDict kwargs specially.
         if ((0, parameterUtils_1.isTypedKwargs)(param) &&
-            printTypeFlags & 1024 /* ExpandTypedDictArgs */ &&
-            param.type.category === 6 /* Class */) {
+            printTypeFlags & 1024 /* PrintTypeFlags.ExpandTypedDictArgs */ &&
+            param.type.category === 6 /* TypeCategory.Class */) {
             param.type.details.typedDictEntries.forEach((v, k) => {
                 const valueTypeString = printTypeInternal(v.valueType, printTypeFlags, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount);
                 paramTypeStrings.push(`${k}: ${valueTypeString}`);
@@ -721,12 +725,12 @@ function printFunctionPartsInternal(type, printTypeFlags, returnTypeCallback, un
             return;
         }
         let paramString = '';
-        if (param.category === 1 /* ArgsList */) {
+        if (param.category === 1 /* ParameterCategory.ArgsList */) {
             if (!param.name || !param.isNameSynthesized) {
                 paramString += '*';
             }
         }
-        else if (param.category === 2 /* KwargsDict */) {
+        else if (param.category === 2 /* ParameterCategory.KwargsDict */) {
             paramString += '**';
         }
         let emittedParamName = false;
@@ -735,7 +739,7 @@ function printFunctionPartsInternal(type, printTypeFlags, returnTypeCallback, un
             sawDefinedName = true;
             emittedParamName = true;
         }
-        else if (printTypeFlags & 256 /* PythonSyntax */) {
+        else if (printTypeFlags & 256 /* PrintTypeFlags.PythonSyntax */) {
             paramString += `__p${index}`;
             sawDefinedName = true;
             emittedParamName = true;
@@ -752,11 +756,11 @@ function printFunctionPartsInternal(type, printTypeFlags, returnTypeCallback, un
                 if (emittedParamName) {
                     paramString += ': ';
                 }
-                else if (param.category === 1 /* ArgsList */ && !(0, types_1.isUnpacked)(paramType)) {
+                else if (param.category === 1 /* ParameterCategory.ArgsList */ && !(0, types_1.isUnpacked)(paramType)) {
                     paramString += '*';
                 }
-                if (param.category === 2 /* KwargsDict */ && (0, types_1.isUnpacked)(paramType)) {
-                    if (printTypeFlags & 256 /* PythonSyntax */) {
+                if (param.category === 2 /* ParameterCategory.KwargsDict */ && (0, types_1.isUnpacked)(paramType)) {
+                    if (printTypeFlags & 256 /* PrintTypeFlags.PythonSyntax */) {
                         // Use "Unpack" because ** isn't legal syntax prior to Python 3.12.
                         paramTypeString = `Unpack[${paramTypeString.substring(1)}]`;
                     }
@@ -767,8 +771,8 @@ function printFunctionPartsInternal(type, printTypeFlags, returnTypeCallback, un
                 }
                 paramString += paramTypeString;
                 if ((0, types_1.isParamSpec)(paramType)) {
-                    if (param.category === 1 /* ArgsList */ ||
-                        param.category === 2 /* KwargsDict */) {
+                    if (param.category === 1 /* ParameterCategory.ArgsList */ ||
+                        param.category === 2 /* ParameterCategory.KwargsDict */) {
                         isParamSpecArgsKwargsParam = true;
                     }
                 }
@@ -776,11 +780,11 @@ function printFunctionPartsInternal(type, printTypeFlags, returnTypeCallback, un
                 // spaces when used with a type annotation.
                 defaultValueAssignment = ' = ';
             }
-            else if ((printTypeFlags & 2 /* OmitTypeArgumentsIfUnknown */) === 0) {
+            else if ((printTypeFlags & 2 /* PrintTypeFlags.OmitTypeArgumentsIfUnknown */) === 0) {
                 if (!param.isNameSynthesized) {
                     paramString += ': ';
                 }
-                if (printTypeFlags & (1 /* PrintUnknownWithAny */ | 256 /* PythonSyntax */)) {
+                if (printTypeFlags & (1 /* PrintTypeFlags.PrintUnknownWithAny */ | 256 /* PrintTypeFlags.PythonSyntax */)) {
                     paramString += 'Any';
                 }
                 else {
@@ -789,7 +793,7 @@ function printFunctionPartsInternal(type, printTypeFlags, returnTypeCallback, un
                 defaultValueAssignment = ' = ';
             }
         }
-        else if (param.category === 0 /* Simple */) {
+        else if (param.category === 0 /* ParameterCategory.Simple */) {
             if (sawDefinedName) {
                 paramString += '/';
             }
@@ -810,17 +814,17 @@ function printFunctionPartsInternal(type, printTypeFlags, returnTypeCallback, un
         }
         // If this is a (...) signature, replace the *args, **kwargs with "...".
         if (types_1.FunctionType.shouldSkipArgsKwargsCompatibilityCheck(type) && !isParamSpecArgsKwargsParam) {
-            if (param.category === 1 /* ArgsList */) {
+            if (param.category === 1 /* ParameterCategory.ArgsList */) {
                 paramString = '...';
             }
-            else if (param.category === 2 /* KwargsDict */) {
+            else if (param.category === 2 /* ParameterCategory.KwargsDict */) {
                 return;
             }
         }
         paramTypeStrings.push(paramString);
     });
     if (type.details.paramSpec) {
-        if (printTypeFlags & 256 /* PythonSyntax */) {
+        if (printTypeFlags & 256 /* PrintTypeFlags.PythonSyntax */) {
             paramTypeStrings.push(`*args: ${type.details.paramSpec}.args`);
             paramTypeStrings.push(`**kwargs: ${type.details.paramSpec}.kwargs`);
         }
@@ -830,12 +834,12 @@ function printFunctionPartsInternal(type, printTypeFlags, returnTypeCallback, un
     }
     const returnType = returnTypeCallback(type);
     const returnTypeString = recursionTypes.length < types_1.maxTypeRecursionCount
-        ? printTypeInternal(returnType, printTypeFlags | 16 /* ParenthesizeUnion */ | 128 /* ParenthesizeCallable */, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount)
+        ? printTypeInternal(returnType, printTypeFlags | 16 /* PrintTypeFlags.ParenthesizeUnion */ | 128 /* PrintTypeFlags.ParenthesizeCallable */, returnTypeCallback, uniqueNameMap, recursionTypes, recursionCount)
         : '';
     return [paramTypeStrings, returnTypeString];
 }
 function _printUnpack(textToWrap, flags) {
-    return flags & 512 /* UseTypingUnpack */ ? `Unpack[${textToWrap}]` : `*${textToWrap}`;
+    return flags & 512 /* PrintTypeFlags.UseTypingUnpack */ ? `Unpack[${textToWrap}]` : `*${textToWrap}`;
 }
 // Surrounds a printed type with Type[...] as many times as needed
 // for the nested instantiable count.
@@ -856,13 +860,13 @@ function _getReadableTypeVarName(type, usePythonSyntax) {
 function _getTypeVarVarianceText(type) {
     var _a;
     const computedVariance = (_a = type.computedVariance) !== null && _a !== void 0 ? _a : type.details.declaredVariance;
-    if (computedVariance === 2 /* Invariant */) {
+    if (computedVariance === 2 /* Variance.Invariant */) {
         return 'invariant';
     }
-    if (computedVariance === 3 /* Covariant */) {
+    if (computedVariance === 3 /* Variance.Covariant */) {
         return 'covariant';
     }
-    if (computedVariance === 4 /* Contravariant */) {
+    if (computedVariance === 4 /* Variance.Contravariant */) {
         return 'contravariant';
     }
     return '';
@@ -884,7 +888,7 @@ class UniqueNameMap {
         recursionCount++;
         if (type.typeAliasInfo) {
             let expandTypeAlias = true;
-            if ((this._printTypeFlags & 32 /* ExpandTypeAlias */) === 0) {
+            if ((this._printTypeFlags & 32 /* PrintTypeFlags.ExpandTypeAlias */) === 0) {
                 expandTypeAlias = false;
             }
             else {
@@ -893,7 +897,7 @@ class UniqueNameMap {
                 }
             }
             if (!expandTypeAlias) {
-                const typeAliasName = (this._printTypeFlags & 4096 /* UseFullyQualifiedNames */) !== 0
+                const typeAliasName = (this._printTypeFlags & 4096 /* PrintTypeFlags.UseFullyQualifiedNames */) !== 0
                     ? type.typeAliasInfo.fullName
                     : type.typeAliasInfo.name;
                 this._addIfUnique(typeAliasName, type, /* useTypeAliasName */ true);
@@ -915,7 +919,7 @@ class UniqueNameMap {
         try {
             recursionTypes.push(type);
             switch (type.category) {
-                case 4 /* Function */: {
+                case 4 /* TypeCategory.Function */: {
                     type.details.parameters.forEach((_, index) => {
                         const paramType = types_1.FunctionType.getEffectiveParameterType(type, index);
                         this.build(paramType, recursionTypes, recursionCount);
@@ -924,20 +928,20 @@ class UniqueNameMap {
                     this.build(returnType, recursionTypes, recursionCount);
                     break;
                 }
-                case 5 /* OverloadedFunction */: {
+                case 5 /* TypeCategory.OverloadedFunction */: {
                     type.overloads.forEach((overload) => {
                         this.build(overload, recursionTypes, recursionCount);
                     });
                     break;
                 }
-                case 6 /* Class */: {
+                case 6 /* TypeCategory.Class */: {
                     if (type.literalValue !== undefined) {
                         break;
                     }
                     let className = type.aliasName;
                     if (!className) {
                         className =
-                            (this._printTypeFlags & 4096 /* UseFullyQualifiedNames */) !== 0
+                            (this._printTypeFlags & 4096 /* PrintTypeFlags.UseFullyQualifiedNames */) !== 0
                                 ? type.details.fullName
                                 : type.details.name;
                     }
@@ -956,7 +960,7 @@ class UniqueNameMap {
                     }
                     break;
                 }
-                case 8 /* Union */: {
+                case 8 /* TypeCategory.Union */: {
                     (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
                         this.build(subtype, recursionTypes, recursionCount);
                     });