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

package/dist/analyzer/typeUtils.js

@@ -54,7 +54,7 @@ var MemberAccessFlags;
     // (__getattr__, etc.) may provide the missing attribute type.
     // This disables this check.
     MemberAccessFlags[MemberAccessFlags["SkipAttributeAccessOverride"] = 512] = "SkipAttributeAccessOverride";
-})(MemberAccessFlags = exports.MemberAccessFlags || (exports.MemberAccessFlags = {}));
+})(MemberAccessFlags || (exports.MemberAccessFlags = MemberAccessFlags = {}));
 var ClassIteratorFlags;
 (function (ClassIteratorFlags) {
     ClassIteratorFlags[ClassIteratorFlags["Default"] = 0] = "Default";
@@ -66,7 +66,7 @@ var ClassIteratorFlags;
     ClassIteratorFlags[ClassIteratorFlags["SkipObjectBaseClass"] = 2] = "SkipObjectBaseClass";
     // Skip the 'type' base class in particular.
     ClassIteratorFlags[ClassIteratorFlags["SkipTypeBaseClass"] = 4] = "SkipTypeBaseClass";
-})(ClassIteratorFlags = exports.ClassIteratorFlags || (exports.ClassIteratorFlags = {}));
+})(ClassIteratorFlags || (exports.ClassIteratorFlags = ClassIteratorFlags = {}));
 var AssignTypeFlags;
 (function (AssignTypeFlags) {
     AssignTypeFlags[AssignTypeFlags["Default"] = 0] = "Default";
@@ -119,7 +119,7 @@ var AssignTypeFlags;
     // the source must be a "concrete" (non-protocol) class. This
     // flag skips this check.
     AssignTypeFlags[AssignTypeFlags["IgnoreProtocolAssignmentCheck"] = 4096] = "IgnoreProtocolAssignmentCheck";
-})(AssignTypeFlags = exports.AssignTypeFlags || (exports.AssignTypeFlags = {}));
+})(AssignTypeFlags || (exports.AssignTypeFlags = AssignTypeFlags = {}));
 // Tracks whether a function signature has been seen before within
 // an expression. For example, in the expression "foo(foo, foo)", the
 // signature for "foo" will be seen three times at three different
@@ -252,7 +252,7 @@ function mapSubtypes(type, callback, sortSubtypes = false) {
                 }
                 const newType = (0, types_1.combineTypes)(typesToCombine);
                 // Do our best to retain type aliases.
-                if (newType.category === 8 /* Union */) {
+                if (newType.category === 8 /* TypeCategory.Union */) {
                     types_1.UnionType.addTypeAliasSource(newType, type);
                 }
                 return newType;
@@ -363,14 +363,14 @@ function compareTypes(a, b, recursionCount = 0) {
         return b.category - a.category;
     }
     switch (a.category) {
-        case 0 /* Unbound */:
-        case 1 /* Unknown */:
-        case 2 /* Any */:
-        case 3 /* Never */:
-        case 8 /* Union */: {
+        case 0 /* TypeCategory.Unbound */:
+        case 1 /* TypeCategory.Unknown */:
+        case 2 /* TypeCategory.Any */:
+        case 3 /* TypeCategory.Never */:
+        case 8 /* TypeCategory.Union */: {
             return 0;
         }
-        case 4 /* Function */: {
+        case 4 /* TypeCategory.Function */: {
             const bFunc = b;
             const aParamCount = a.details.parameters.length;
             const bParamCount = bFunc.details.parameters.length;
@@ -402,7 +402,7 @@ function compareTypes(a, b, recursionCount = 0) {
             }
             return 0;
         }
-        case 5 /* OverloadedFunction */: {
+        case 5 /* TypeCategory.OverloadedFunction */: {
             const bOver = b;
             const aOverloadCount = a.overloads.length;
             const bOverloadCount = bOver.overloads.length;
@@ -417,7 +417,7 @@ function compareTypes(a, b, recursionCount = 0) {
             }
             return 0;
         }
-        case 6 /* Class */: {
+        case 6 /* TypeCategory.Class */: {
             const bClass = b;
             // Sort instances before instantiables.
             if ((0, types_1.isClassInstance)(a) && (0, types_1.isInstantiableClass)(bClass)) {
@@ -478,12 +478,12 @@ function compareTypes(a, b, recursionCount = 0) {
             }
             return 0;
         }
-        case 7 /* Module */: {
+        case 7 /* TypeCategory.Module */: {
             const aName = a.moduleName;
             const bName = b.moduleName;
             return aName < bName ? -1 : aName === bName ? 0 : 1;
         }
-        case 9 /* TypeVar */: {
+        case 9 /* TypeCategory.TypeVar */: {
             const aName = a.details.name;
             const bName = b.details.name;
             return aName < bName ? -1 : aName === bName ? 0 : 1;
@@ -548,7 +548,7 @@ exports.preserveUnknown = preserveUnknown;
 // Determines whether the specified type is a type that can be
 // combined with other types for a union.
 function isUnionableType(subtypes) {
-    let typeFlags = 2 /* Instance */ | 1 /* Instantiable */;
+    let typeFlags = 2 /* TypeFlags.Instance */ | 1 /* TypeFlags.Instantiable */;
     for (const subtype of subtypes) {
         typeFlags &= subtype.flags;
     }
@@ -556,7 +556,7 @@ function isUnionableType(subtypes) {
     // and None) are both instances and instantiable. It's OK to
     // include some of these, but at least one subtype needs to
     // be definitively instantiable (not an instance).
-    return (typeFlags & 1 /* Instantiable */) !== 0 && (typeFlags & 2 /* Instance */) === 0;
+    return (typeFlags & 1 /* TypeFlags.Instantiable */) !== 0 && (typeFlags & 2 /* TypeFlags.Instance */) === 0;
 }
 exports.isUnionableType = isUnionableType;
 function derivesFromAnyOrUnknown(type) {
@@ -585,16 +585,16 @@ function getFullNameOfType(type) {
         return type.typeAliasInfo.fullName;
     }
     switch (type.category) {
-        case 2 /* Any */:
-        case 1 /* Unknown */:
+        case 2 /* TypeCategory.Any */:
+        case 1 /* TypeCategory.Unknown */:
             return 'typing.Any';
-        case 6 /* Class */:
+        case 6 /* TypeCategory.Class */:
             return type.details.fullName;
-        case 4 /* Function */:
+        case 4 /* TypeCategory.Function */:
             return type.details.fullName;
-        case 7 /* Module */:
+        case 7 /* TypeCategory.Module */:
             return type.moduleName;
-        case 5 /* OverloadedFunction */:
+        case 5 /* TypeCategory.OverloadedFunction */:
             return type.overloads[0].details.fullName;
     }
     return undefined;
@@ -605,37 +605,37 @@ function addConditionToType(type, condition) {
         return type;
     }
     switch (type.category) {
-        case 0 /* Unbound */:
-        case 1 /* Unknown */:
-        case 2 /* Any */:
-        case 3 /* Never */:
-        case 7 /* Module */:
-        case 9 /* TypeVar */:
+        case 0 /* TypeCategory.Unbound */:
+        case 1 /* TypeCategory.Unknown */:
+        case 2 /* TypeCategory.Any */:
+        case 3 /* TypeCategory.Never */:
+        case 7 /* TypeCategory.Module */:
+        case 9 /* TypeCategory.TypeVar */:
             return type;
-        case 4 /* Function */:
+        case 4 /* TypeCategory.Function */:
             return types_1.TypeBase.cloneForCondition(type, types_1.TypeCondition.combine(type.condition, condition));
-        case 5 /* OverloadedFunction */:
+        case 5 /* TypeCategory.OverloadedFunction */:
             return types_1.OverloadedFunctionType.create(type.overloads.map((t) => addConditionToType(t, condition)));
-        case 6 /* Class */:
+        case 6 /* TypeCategory.Class */:
             return types_1.TypeBase.cloneForCondition(type, types_1.TypeCondition.combine(type.condition, condition));
-        case 8 /* Union */:
+        case 8 /* TypeCategory.Union */:
             return (0, types_1.combineTypes)(type.subtypes.map((t) => addConditionToType(t, condition)));
     }
 }
 exports.addConditionToType = addConditionToType;
 function getTypeCondition(type) {
     switch (type.category) {
-        case 0 /* Unbound */:
-        case 1 /* Unknown */:
-        case 2 /* Any */:
-        case 3 /* Never */:
-        case 7 /* Module */:
-        case 9 /* TypeVar */:
-        case 5 /* OverloadedFunction */:
-        case 8 /* Union */:
+        case 0 /* TypeCategory.Unbound */:
+        case 1 /* TypeCategory.Unknown */:
+        case 2 /* TypeCategory.Any */:
+        case 3 /* TypeCategory.Never */:
+        case 7 /* TypeCategory.Module */:
+        case 9 /* TypeCategory.TypeVar */:
+        case 5 /* TypeCategory.OverloadedFunction */:
+        case 8 /* TypeCategory.Union */:
             return undefined;
-        case 6 /* Class */:
-        case 4 /* Function */:
+        case 6 /* TypeCategory.Class */:
+        case 4 /* TypeCategory.Function */:
             return type.condition;
     }
 }
@@ -650,7 +650,7 @@ exports.isTypeAliasPlaceholder = isTypeAliasPlaceholder;
 // within the specified type. It's OK if it's used indirectly as
 // a type argument.
 function isTypeAliasRecursive(typeAliasPlaceholder, type) {
-    if (type.category !== 8 /* Union */) {
+    if (type.category !== 8 /* TypeCategory.Union */) {
         if (type === typeAliasPlaceholder) {
             return true;
         }
@@ -754,7 +754,7 @@ function getUnknownTypeForTypeVar(typeVar) {
 exports.getUnknownTypeForTypeVar = getUnknownTypeForTypeVar;
 // Returns the "Unknown" equivalent for a ParamSpec.
 function getUnknownTypeForParamSpec() {
-    const newFunction = types_1.FunctionType.createInstance('', '', '', 65536 /* ParamSpecValue */ | 32768 /* SkipArgsKwargsCompatibilityCheck */);
+    const newFunction = types_1.FunctionType.createInstance('', '', '', 65536 /* FunctionTypeFlags.ParamSpecValue */ | 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */);
     types_1.FunctionType.addDefaultParameters(newFunction);
     return newFunction;
 }
@@ -887,7 +887,7 @@ function isCallableType(type) {
         if (types_1.TypeBase.isInstantiable(type)) {
             return true;
         }
-        const callMember = lookUpObjectMember(type, '__call__', 16 /* SkipInstanceMembers */);
+        const callMember = lookUpObjectMember(type, '__call__', 16 /* MemberAccessFlags.SkipInstanceMembers */);
         return !!callMember;
     }
     if ((0, types_1.isUnion)(type)) {
@@ -1097,13 +1097,13 @@ exports.transformExpectedType = transformExpectedType;
 // appears in a parent and a child, the child overrides the parent.
 function getProtocolSymbols(classType) {
     const symbolMap = new Map();
-    if ((classType.details.flags & 8192 /* ProtocolClass */) !== 0) {
-        getProtocolSymbolsRecursive(classType, symbolMap, 8192 /* ProtocolClass */);
+    if ((classType.details.flags & 8192 /* ClassTypeFlags.ProtocolClass */) !== 0) {
+        getProtocolSymbolsRecursive(classType, symbolMap, 8192 /* ClassTypeFlags.ProtocolClass */);
     }
     return symbolMap;
 }
 exports.getProtocolSymbols = getProtocolSymbols;
-function getProtocolSymbolsRecursive(classType, symbolMap, classFlags = 8192 /* ProtocolClass */, recursionCount = 0) {
+function getProtocolSymbolsRecursive(classType, symbolMap, classFlags = 8192 /* ClassTypeFlags.ProtocolClass */, recursionCount = 0) {
     if (recursionCount > types_1.maxTypeRecursionCount) {
         return;
     }
@@ -1160,7 +1160,7 @@ function getContainerDepth(type, recursionCount = 0) {
     return 1 + maxChildDepth;
 }
 exports.getContainerDepth = getContainerDepth;
-function lookUpObjectMember(objectType, memberName, flags = 0 /* Default */, skipMroClass) {
+function lookUpObjectMember(objectType, memberName, flags = 0 /* MemberAccessFlags.Default */, skipMroClass) {
     if ((0, types_1.isClassInstance)(objectType)) {
         return lookUpClassMember(objectType, memberName, flags, skipMroClass);
     }
@@ -1169,7 +1169,7 @@ function lookUpObjectMember(objectType, memberName, flags = 0 /* Default */, ski
 exports.lookUpObjectMember = lookUpObjectMember;
 // Looks up a member in a class using the multiple-inheritance rules
 // defined by Python.
-function lookUpClassMember(classType, memberName, flags = 0 /* Default */, skipMroClass) {
+function lookUpClassMember(classType, memberName, flags = 0 /* MemberAccessFlags.Default */, skipMroClass) {
     var _a;
     const memberItr = getClassMemberIterator(classType, memberName, flags, skipMroClass);
     return (_a = memberItr.next()) === null || _a === void 0 ? void 0 : _a.value;
@@ -1185,24 +1185,24 @@ exports.lookUpClassMember = lookUpClassMember;
 // (self) -> Iterator[str].
 // If skipMroClass is defined, all MRO classes up to and including that class
 // are skipped.
-function* getClassMemberIterator(classType, memberName, flags = 0 /* Default */, skipMroClass) {
-    const declaredTypesOnly = (flags & 64 /* DeclaredTypesOnly */) !== 0;
+function* getClassMemberIterator(classType, memberName, flags = 0 /* MemberAccessFlags.Default */, skipMroClass) {
+    const declaredTypesOnly = (flags & 64 /* MemberAccessFlags.DeclaredTypesOnly */) !== 0;
     let skippedUndeclaredType = false;
     if ((0, types_1.isClass)(classType)) {
-        let classFlags = 0 /* Default */;
-        if (flags & 1 /* SkipOriginalClass */) {
+        let classFlags = 0 /* ClassIteratorFlags.Default */;
+        if (flags & 1 /* MemberAccessFlags.SkipOriginalClass */) {
             if ((0, types_1.isClass)(classType)) {
                 skipMroClass = classType;
             }
         }
-        if (flags & 2 /* SkipBaseClasses */) {
-            classFlags = classFlags | 1 /* SkipBaseClasses */;
+        if (flags & 2 /* MemberAccessFlags.SkipBaseClasses */) {
+            classFlags = classFlags | 1 /* ClassIteratorFlags.SkipBaseClasses */;
         }
-        if (flags & 4 /* SkipObjectBaseClass */) {
-            classFlags = classFlags | 2 /* SkipObjectBaseClass */;
+        if (flags & 4 /* MemberAccessFlags.SkipObjectBaseClass */) {
+            classFlags = classFlags | 2 /* ClassIteratorFlags.SkipObjectBaseClass */;
         }
-        if (flags & 8 /* SkipTypeBaseClass */) {
-            classFlags = classFlags | 4 /* SkipTypeBaseClass */;
+        if (flags & 8 /* MemberAccessFlags.SkipTypeBaseClass */) {
+            classFlags = classFlags | 4 /* ClassIteratorFlags.SkipTypeBaseClass */;
         }
         const classItr = getClassIterator(classType, classFlags, skipMroClass);
         for (const [mroClass, specializedMroClass] of classItr) {
@@ -1211,7 +1211,7 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* Default */,
                     // The class derives from an unknown type, so all bets are off
                     // when trying to find a member. Return an unknown symbol.
                     const cm = {
-                        symbol: symbol_1.Symbol.createWithType(0 /* None */, mroClass),
+                        symbol: symbol_1.Symbol.createWithType(0 /* SymbolFlags.None */, mroClass),
                         isInstanceMember: false,
                         isClassMember: true,
                         isClassVar: false,
@@ -1228,7 +1228,7 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* Default */,
             }
             const memberFields = specializedMroClass.details.fields;
             // Look at instance members first if requested.
-            if ((flags & 16 /* SkipInstanceMembers */) === 0) {
+            if ((flags & 16 /* MemberAccessFlags.SkipInstanceMembers */) === 0) {
                 const symbol = memberFields.get(memberName);
                 if (symbol && symbol.isInstanceMember()) {
                     const hasDeclaredType = symbol.hasTypedDeclarations();
@@ -1250,7 +1250,7 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* Default */,
                 }
             }
             // Next look at class members.
-            if ((flags & 32 /* SkipClassMembers */) === 0) {
+            if ((flags & 32 /* MemberAccessFlags.SkipClassMembers */) === 0) {
                 const symbol = memberFields.get(memberName);
                 if (symbol && symbol.isClassMember()) {
                     const hasDeclaredType = symbol.hasTypedDeclarations();
@@ -1266,7 +1266,7 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* Default */,
                         const isTypedDict = types_1.ClassType.isTypedDictClass(specializedMroClass);
                         if (hasDeclaredType && (isDataclass || isTypedDict)) {
                             const decls = symbol.getDeclarations();
-                            if (decls.length > 0 && decls[0].type === 1 /* Variable */) {
+                            if (decls.length > 0 && decls[0].type === 1 /* DeclarationType.Variable */) {
                                 isInstanceMember = true;
                                 isClassMember = isDataclass;
                             }
@@ -1293,7 +1293,7 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* Default */,
         // The class derives from an unknown type, so all bets are off
         // when trying to find a member. Return an Any or Unknown symbol.
         const cm = {
-            symbol: symbol_1.Symbol.createWithType(0 /* None */, classType),
+            symbol: symbol_1.Symbol.createWithType(0 /* SymbolFlags.None */, classType),
             isInstanceMember: false,
             isClassMember: true,
             isClassVar: false,
@@ -1306,7 +1306,7 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* Default */,
     return undefined;
 }
 exports.getClassMemberIterator = getClassMemberIterator;
-function* getClassIterator(classType, flags = 0 /* Default */, skipMroClass) {
+function* getClassIterator(classType, flags = 0 /* ClassIteratorFlags.Default */, skipMroClass) {
     if ((0, types_1.isClass)(classType)) {
         let foundSkipMroClass = skipMroClass === undefined;
         for (const mroClass of classType.details.mro) {
@@ -1327,7 +1327,7 @@ function* getClassIterator(classType, flags = 0 /* Default */, skipMroClass) {
             // it in the context of classType.
             const specializedMroClass = partiallySpecializeType(mroClass, classType);
             // Should we ignore members on the 'object' base class?
-            if (flags & 2 /* SkipObjectBaseClass */) {
+            if (flags & 2 /* ClassIteratorFlags.SkipObjectBaseClass */) {
                 if ((0, types_1.isInstantiableClass)(specializedMroClass)) {
                     if (types_1.ClassType.isBuiltIn(specializedMroClass, 'object')) {
                         break;
@@ -1335,7 +1335,7 @@ function* getClassIterator(classType, flags = 0 /* Default */, skipMroClass) {
                 }
             }
             // Should we ignore members on the 'type' base class?
-            if (flags & 4 /* SkipTypeBaseClass */) {
+            if (flags & 4 /* ClassIteratorFlags.SkipTypeBaseClass */) {
                 if ((0, types_1.isInstantiableClass)(specializedMroClass)) {
                     if (types_1.ClassType.isBuiltIn(specializedMroClass, 'type')) {
                         break;
@@ -1343,7 +1343,7 @@ function* getClassIterator(classType, flags = 0 /* Default */, skipMroClass) {
                 }
             }
             yield [mroClass, specializedMroClass];
-            if ((flags & 1 /* SkipBaseClasses */) !== 0) {
+            if ((flags & 1 /* ClassIteratorFlags.SkipBaseClasses */) !== 0) {
                 break;
             }
         }
@@ -1549,12 +1549,12 @@ function setTypeArgumentsRecursive(destType, srcType, typeVarContext, recursionC
         return;
     }
     switch (destType.category) {
-        case 8 /* Union */:
+        case 8 /* TypeCategory.Union */:
             doForEachSubtype(destType, (subtype) => {
                 setTypeArgumentsRecursive(subtype, srcType, typeVarContext, recursionCount);
             });
             break;
-        case 6 /* Class */:
+        case 6 /* TypeCategory.Class */:
             if (destType.typeArguments) {
                 destType.typeArguments.forEach((typeArg) => {
                     setTypeArgumentsRecursive(typeArg, srcType, typeVarContext, recursionCount);
@@ -1566,7 +1566,7 @@ function setTypeArgumentsRecursive(destType, srcType, typeVarContext, recursionC
                 });
             }
             break;
-        case 4 /* Function */:
+        case 4 /* TypeCategory.Function */:
             if (destType.specializedTypes) {
                 destType.specializedTypes.parameterTypes.forEach((paramType) => {
                     setTypeArgumentsRecursive(paramType, srcType, typeVarContext, recursionCount);
@@ -1590,12 +1590,12 @@ function setTypeArgumentsRecursive(destType, srcType, typeVarContext, recursionC
                 }
             }
             break;
-        case 5 /* OverloadedFunction */:
+        case 5 /* TypeCategory.OverloadedFunction */:
             destType.overloads.forEach((subtype) => {
                 setTypeArgumentsRecursive(subtype, srcType, typeVarContext, recursionCount);
             });
             break;
-        case 9 /* TypeVar */:
+        case 9 /* TypeCategory.TypeVar */:
             if (!typeVarContext.getPrimarySignature().getTypeVar(destType)) {
                 typeVarContext.setTypeVarType(destType, srcType);
             }
@@ -1788,7 +1788,7 @@ function convertToInstance(type, includeSubclasses = true) {
     }
     let result = mapSubtypes(type, (subtype) => {
         switch (subtype.category) {
-            case 6 /* Class */: {
+            case 6 /* TypeCategory.Class */: {
                 // Handle type[x] as a special case.
                 if (types_1.ClassType.isBuiltIn(subtype, 'type')) {
                     if (types_1.TypeBase.isInstance(subtype)) {
@@ -1809,19 +1809,19 @@ function convertToInstance(type, includeSubclasses = true) {
                 }
                 return types_1.ClassType.cloneAsInstance(subtype, includeSubclasses);
             }
-            case 4 /* Function */: {
+            case 4 /* TypeCategory.Function */: {
                 if (types_1.TypeBase.isInstantiable(subtype)) {
                     return types_1.FunctionType.cloneAsInstance(subtype);
                 }
                 break;
             }
-            case 9 /* TypeVar */: {
+            case 9 /* TypeCategory.TypeVar */: {
                 if (types_1.TypeBase.isInstantiable(subtype)) {
                     return types_1.TypeVarType.cloneAsInstance(subtype);
                 }
                 break;
             }
-            case 2 /* Any */: {
+            case 2 /* TypeCategory.Any */: {
                 return types_1.AnyType.convertToInstance(subtype);
             }
         }
@@ -1849,13 +1849,13 @@ function convertToInstantiable(type, includeSubclasses = true) {
     }
     let result = mapSubtypes(type, (subtype) => {
         switch (subtype.category) {
-            case 6 /* Class */: {
+            case 6 /* TypeCategory.Class */: {
                 return types_1.ClassType.cloneAsInstantiable(subtype, includeSubclasses);
             }
-            case 4 /* Function */: {
+            case 4 /* TypeCategory.Function */: {
                 return types_1.FunctionType.cloneAsInstantiable(subtype);
             }
-            case 9 /* TypeVar */: {
+            case 9 /* TypeCategory.TypeVar */: {
                 return types_1.TypeVarType.cloneAsInstantiable(subtype);
             }
         }
@@ -2173,8 +2173,8 @@ function removeParamSpecVariadicsFromFunction(type) {
     }
     const argsParam = type.details.parameters[paramCount - 2];
     const kwargsParam = type.details.parameters[paramCount - 1];
-    if (argsParam.category !== 1 /* ArgsList */ ||
-        kwargsParam.category !== 2 /* KwargsDict */ ||
+    if (argsParam.category !== 1 /* ParameterCategory.ArgsList */ ||
+        kwargsParam.category !== 2 /* ParameterCategory.KwargsDict */ ||
         !(0, types_1.isParamSpec)(argsParam.type) ||
         !(0, types_1.isParamSpec)(kwargsParam.type) ||
         !(0, types_1.isTypeSame)(argsParam.type, kwargsParam.type)) {
@@ -2271,7 +2271,7 @@ function _requiresSpecialization(type, options, recursionCount = 0) {
         return true;
     }
     switch (type.category) {
-        case 6 /* Class */: {
+        case 6 /* TypeCategory.Class */: {
             if (types_1.ClassType.isPseudoGenericClass(type) && (options === null || options === void 0 ? void 0 : options.ignorePseudoGeneric)) {
                 return false;
             }
@@ -2283,7 +2283,7 @@ function _requiresSpecialization(type, options, recursionCount = 0) {
             }
             return types_1.ClassType.getTypeParameters(type).length > 0;
         }
-        case 4 /* Function */: {
+        case 4 /* TypeCategory.Function */: {
             if (type.details.paramSpec) {
                 return true;
             }
@@ -2307,13 +2307,13 @@ function _requiresSpecialization(type, options, recursionCount = 0) {
             }
             return false;
         }
-        case 5 /* OverloadedFunction */: {
+        case 5 /* TypeCategory.OverloadedFunction */: {
             return type.overloads.some((overload) => requiresSpecialization(overload, options, recursionCount));
         }
-        case 8 /* Union */: {
+        case 8 /* TypeCategory.Union */: {
             return type.subtypes.some((subtype) => requiresSpecialization(subtype, options, recursionCount));
         }
-        case 9 /* TypeVar */: {
+        case 9 /* TypeCategory.TypeVar */: {
             // Most TypeVar types need to be specialized.
             if (!type.details.recursiveTypeAliasName) {
                 if (type.details.isSynthesizedSelf && (options === null || options === void 0 ? void 0 : options.ignoreSelf)) {
@@ -2332,13 +2332,13 @@ function _requiresSpecialization(type, options, recursionCount = 0) {
 }
 // Combines two variances to produce a resulting variance.
 function combineVariances(variance1, variance2) {
-    if (variance1 === 1 /* Unknown */) {
+    if (variance1 === 1 /* Variance.Unknown */) {
         return variance2;
     }
-    if (variance2 === 2 /* Invariant */ ||
-        (variance2 === 3 /* Covariant */ && variance1 === 4 /* Contravariant */) ||
-        (variance2 === 4 /* Contravariant */ && variance1 === 3 /* Covariant */)) {
-        return 2 /* Invariant */;
+    if (variance2 === 2 /* Variance.Invariant */ ||
+        (variance2 === 3 /* Variance.Covariant */ && variance1 === 4 /* Variance.Contravariant */) ||
+        (variance2 === 4 /* Variance.Contravariant */ && variance1 === 3 /* Variance.Covariant */)) {
+        return 2 /* Variance.Invariant */;
     }
     return variance1;
 }
@@ -2346,12 +2346,12 @@ exports.combineVariances = combineVariances;
 // Determines if the variance of the type argument for a generic class is compatible
 // With the declared variance of the corresponding type parameter.
 function isVarianceOfTypeArgumentCompatible(type, typeParamVariance) {
-    if (typeParamVariance === 1 /* Unknown */ || typeParamVariance === 0 /* Auto */) {
+    if (typeParamVariance === 1 /* Variance.Unknown */ || typeParamVariance === 0 /* Variance.Auto */) {
         return true;
     }
     if ((0, types_1.isTypeVar)(type) && !type.details.isParamSpec && !type.details.isVariadic) {
         const typeArgVariance = type.details.declaredVariance;
-        if (typeArgVariance === 4 /* Contravariant */ || typeArgVariance === 3 /* Covariant */) {
+        if (typeArgVariance === 4 /* Variance.Contravariant */ || typeArgVariance === 3 /* Variance.Covariant */) {
             return typeArgVariance === typeParamVariance;
         }
     }
@@ -2366,23 +2366,23 @@ function isVarianceOfTypeArgumentCompatible(type, typeParamVariance) {
                     typeArgType = type.typeArguments[index];
                 }
                 const declaredVariance = typeParam.details.declaredVariance;
-                if (declaredVariance === 0 /* Auto */) {
+                if (declaredVariance === 0 /* Variance.Auto */) {
                     return true;
                 }
-                let effectiveVariance = 2 /* Invariant */;
-                if (declaredVariance === 3 /* Covariant */) {
+                let effectiveVariance = 2 /* Variance.Invariant */;
+                if (declaredVariance === 3 /* Variance.Covariant */) {
                     // If the declared variance is covariant, the effective variance
                     // is simply copied from the type param variance.
                     effectiveVariance = typeParamVariance;
                 }
-                else if (declaredVariance === 4 /* Contravariant */) {
+                else if (declaredVariance === 4 /* Variance.Contravariant */) {
                     // If the declared variance is contravariant, it flips the
                     // effective variance from contravariant to covariant or vice versa.
-                    if (typeParamVariance === 3 /* Covariant */) {
-                        effectiveVariance = 4 /* Contravariant */;
+                    if (typeParamVariance === 3 /* Variance.Covariant */) {
+                        effectiveVariance = 4 /* Variance.Contravariant */;
                     }
-                    else if (typeParamVariance === 4 /* Contravariant */) {
-                        effectiveVariance = 3 /* Covariant */;
+                    else if (typeParamVariance === 4 /* Variance.Contravariant */) {
+                        effectiveVariance = 3 /* Variance.Covariant */;
                     }
                 }
                 return isVarianceOfTypeArgumentCompatible(typeArgType !== null && typeArgType !== void 0 ? typeArgType : types_1.UnknownType.create(), effectiveVariance);
@@ -2530,27 +2530,27 @@ function addDeclaringModuleNamesForType(type, moduleList, recursionCount = 0) {
         }
     };
     switch (type.category) {
-        case 6 /* Class */: {
+        case 6 /* TypeCategory.Class */: {
             addIfUnique(type.details.moduleName);
             break;
         }
-        case 4 /* Function */: {
+        case 4 /* TypeCategory.Function */: {
             addIfUnique(type.details.moduleName);
             break;
         }
-        case 5 /* OverloadedFunction */: {
+        case 5 /* TypeCategory.OverloadedFunction */: {
             type.overloads.forEach((overload) => {
                 addDeclaringModuleNamesForType(overload, moduleList, recursionCount);
             });
             break;
         }
-        case 8 /* Union */: {
+        case 8 /* TypeCategory.Union */: {
             doForEachSubtype(type, (subtype) => {
                 addDeclaringModuleNamesForType(subtype, moduleList, recursionCount);
             });
             break;
         }
-        case 7 /* Module */: {
+        case 7 /* TypeCategory.Module */: {
             addIfUnique(type.moduleName);
             break;
         }
@@ -2558,13 +2558,13 @@ function addDeclaringModuleNamesForType(type, moduleList, recursionCount = 0) {
 }
 function convertTypeToParamSpecValue(type) {
     if ((0, types_1.isParamSpec)(type)) {
-        const newFunction = types_1.FunctionType.createInstance('', '', '', 65536 /* ParamSpecValue */);
+        const newFunction = types_1.FunctionType.createInstance('', '', '', 65536 /* FunctionTypeFlags.ParamSpecValue */);
         newFunction.details.paramSpec = type;
         newFunction.details.typeVarScopeId = getTypeVarScopeId(type);
         return newFunction;
     }
     if ((0, types_1.isFunction)(type)) {
-        const newFunction = types_1.FunctionType.createInstance('', '', '', type.details.flags | 65536 /* ParamSpecValue */, type.details.docString);
+        const newFunction = types_1.FunctionType.createInstance('', '', '', type.details.flags | 65536 /* FunctionTypeFlags.ParamSpecValue */, type.details.docString);
         type.details.parameters.forEach((param, index) => {
             types_1.FunctionType.addParameter(newFunction, {
                 category: param.category,
@@ -2594,7 +2594,7 @@ function convertParamSpecValueToType(paramSpecValue, omitParamSpec = false) {
     }
     if (hasParameters || !paramSpecValue.details.paramSpec || omitParamSpec) {
         // Create a function type from the param spec entries.
-        const functionType = types_1.FunctionType.createInstance('', '', '', 65536 /* ParamSpecValue */ | paramSpecValue.details.flags);
+        const functionType = types_1.FunctionType.createInstance('', '', '', 65536 /* FunctionTypeFlags.ParamSpecValue */ | paramSpecValue.details.flags);
         functionType.details.paramSpecTypeVarScopeId = paramSpecValue.details.typeVarScopeId;
         paramSpecValue.details.parameters.forEach((entry) => {
             types_1.FunctionType.addParameter(functionType, {
@@ -2960,8 +2960,8 @@ class TypeVarTransformer {
                 const kwargsParam = functionType.details.parameters[functionType.details.parameters.length - 1];
                 const argsParamType = types_1.FunctionType.getEffectiveParameterType(functionType, functionType.details.parameters.length - 2);
                 const kwargsParamType = types_1.FunctionType.getEffectiveParameterType(functionType, functionType.details.parameters.length - 1);
-                if (argsParam.category === 1 /* ArgsList */ &&
-                    kwargsParam.category === 2 /* KwargsDict */ &&
+                if (argsParam.category === 1 /* ParameterCategory.ArgsList */ &&
+                    kwargsParam.category === 2 /* ParameterCategory.KwargsDict */ &&
                     (0, types_1.isParamSpec)(argsParamType) &&
                     (0, types_1.isParamSpec)(kwargsParamType) &&
                     (0, types_1.isTypeSame)(argsParamType, kwargsParamType)) {
@@ -2996,7 +2996,7 @@ class TypeVarTransformer {
                 specializedDefaultArgs.push(defaultArgType);
                 if (variadicParamIndex === undefined &&
                     (0, types_1.isVariadicTypeVar)(paramType) &&
-                    functionType.details.parameters[i].category === 1 /* ArgsList */) {
+                    functionType.details.parameters[i].category === 1 /* ParameterCategory.ArgsList */) {
                     variadicParamIndex = i;
                     if ((0, types_1.isClassInstance)(specializedType) &&
                         isTupleClass(specializedType) &&
@@ -3028,7 +3028,7 @@ class TypeVarTransformer {
             }
             // Unpack the tuple and synthesize a new function in the process.
             const newFunctionType = types_1.TypeBase.isInstantiable(functionType)
-                ? types_1.FunctionType.createInstantiable(functionType.details.flags | 64 /* SynthesizedMethod */)
+                ? types_1.FunctionType.createInstantiable(functionType.details.flags | 64 /* FunctionTypeFlags.SynthesizedMethod */)
                 : types_1.FunctionType.createSynthesizedInstance('', functionType.details.flags);
             let insertKeywordOnlySeparator = false;
             let swallowPositionOnlySeparator = false;
@@ -3039,8 +3039,8 @@ class TypeVarTransformer {
                     variadicTypesToUnpack.forEach((unpackedType) => {
                         types_1.FunctionType.addParameter(newFunctionType, {
                             category: unpackedType.isUnbounded || (0, types_1.isVariadicTypeVar)(unpackedType.type)
-                                ? 1 /* ArgsList */
-                                : 0 /* Simple */,
+                                ? 1 /* ParameterCategory.ArgsList */
+                                : 0 /* ParameterCategory.Simple */,
                             name: `__p${newFunctionType.details.parameters.length}`,
                             isNameSynthesized: true,
                             type: unpackedType.type,
@@ -3062,14 +3062,14 @@ class TypeVarTransformer {
                     if ((0, types_1.isKeywordOnlySeparator)(param)) {
                         insertKeywordOnlySeparator = false;
                     }
-                    else if (param.category === 2 /* KwargsDict */) {
+                    else if (param.category === 2 /* ParameterCategory.KwargsDict */) {
                         insertKeywordOnlySeparator = false;
                     }
                     // Insert a keyword-only separator parameter if we previously
                     // unpacked a variadic TypeVar.
-                    if (param.category === 0 /* Simple */ && param.name && insertKeywordOnlySeparator) {
+                    if (param.category === 0 /* ParameterCategory.Simple */ && param.name && insertKeywordOnlySeparator) {
                         types_1.FunctionType.addParameter(newFunctionType, {
-                            category: 1 /* ArgsList */,
+                            category: 1 /* ParameterCategory.ArgsList */,
                             type: types_1.UnknownType.create(),
                         });
                         insertKeywordOnlySeparator = false;
@@ -3078,7 +3078,7 @@ class TypeVarTransformer {
                     if (param.name && param.isNameSynthesized) {
                         param.name = `__p${newFunctionType.details.parameters.length}`;
                     }
-                    if (param.category !== 0 /* Simple */ || param.name || !swallowPositionOnlySeparator) {
+                    if (param.category !== 0 /* ParameterCategory.Simple */ || param.name || !swallowPositionOnlySeparator) {
                         types_1.FunctionType.addParameter(newFunctionType, param);
                     }
                 }
@@ -3160,7 +3160,7 @@ class UniqueFunctionSignatureTransformer extends TypeVarTransformer {
                 // Create new type variables with the same scope but with
                 // different (unique) names.
                 sourceType.details.typeParameters.forEach((typeParam) => {
-                    if (typeParam.scopeType === 1 /* Function */) {
+                    if (typeParam.scopeType === 1 /* TypeVarScopeType.Function */) {
                         let replacement = types_1.TypeVarType.cloneForNewName(typeParam, `${typeParam.details.name}(${offsetIndex})`);
                         if (replacement.details.isParamSpec) {
                             replacement = convertTypeToParamSpecValue(replacement);
@@ -3402,7 +3402,7 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         const filteredOverloads = [];
         doForEachSubtype((0, types_1.combineTypes)(overloadTypes), (subtype) => {
             (0, debug_1.assert)((0, types_1.isFunction)(subtype));
-            subtype = types_1.FunctionType.cloneWithNewFlags(subtype, subtype.details.flags | 256 /* Overloaded */);
+            subtype = types_1.FunctionType.cloneWithNewFlags(subtype, subtype.details.flags | 256 /* FunctionTypeFlags.Overloaded */);
             filteredOverloads.push(subtype);
         });
         if (filteredOverloads.length === 1) {