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

package/dist/analyzer/types.js

@@ -39,7 +39,7 @@ var TypeCategory;
     TypeCategory[TypeCategory["Union"] = 8] = "Union";
     // Type variable (defined with TypeVar)
     TypeCategory[TypeCategory["TypeVar"] = 9] = "TypeVar";
-})(TypeCategory = exports.TypeCategory || (exports.TypeCategory = {}));
+})(TypeCategory || (exports.TypeCategory = TypeCategory = {}));
 var TypeFlags;
 (function (TypeFlags) {
     TypeFlags[TypeFlags["None"] = 0] = "None";
@@ -52,7 +52,7 @@ var TypeFlags;
     TypeFlags[TypeFlags["Annotated"] = 4] = "Annotated";
     // This type is a special form like "UnionType".
     TypeFlags[TypeFlags["SpecialForm"] = 8] = "SpecialForm";
-})(TypeFlags = exports.TypeFlags || (exports.TypeFlags = {}));
+})(TypeFlags || (exports.TypeFlags = TypeFlags = {}));
 exports.WildcardTypeVarScopeId = '*';
 exports.InScopePlaceholderScopeId = '-';
 class EnumLiteral {
@@ -70,28 +70,30 @@ exports.EnumLiteral = EnumLiteral;
 // This constant controls the maximum number of nested types (i.e. types
 // used as type arguments or parameter types in other types) before we
 // give up. This constant was previously set to 32, but there were certain
-// pathological recursive types where this resulted in a hang.
-exports.maxTypeRecursionCount = 10;
+// pathological recursive types where this resulted in a hang. It was also
+// previously lowered to 10, but this caused some legitimate failures in
+// code that used numpy.
+exports.maxTypeRecursionCount = 12;
 var TypeBase;
 (function (TypeBase) {
     function isInstantiable(type) {
-        return (type.flags & 1 /* Instantiable */) !== 0;
+        return (type.flags & 1 /* TypeFlags.Instantiable */) !== 0;
     }
     TypeBase.isInstantiable = isInstantiable;
     function isInstance(type) {
-        return (type.flags & 2 /* Instance */) !== 0;
+        return (type.flags & 2 /* TypeFlags.Instance */) !== 0;
     }
     TypeBase.isInstance = isInstance;
     function isAnnotated(type) {
-        return (type.flags & 4 /* Annotated */) !== 0;
+        return (type.flags & 4 /* TypeFlags.Annotated */) !== 0;
     }
     TypeBase.isAnnotated = isAnnotated;
     function isSpecialForm(type) {
-        return (type.flags & 8 /* SpecialForm */) !== 0;
+        return (type.flags & 8 /* TypeFlags.SpecialForm */) !== 0;
     }
     TypeBase.isSpecialForm = isSpecialForm;
     function setSpecialForm(type) {
-        return (type.flags |= 8 /* SpecialForm */);
+        return (type.flags |= 8 /* TypeFlags.SpecialForm */);
     }
     TypeBase.setSpecialForm = setSpecialForm;
     function isAmbiguous(type) {
@@ -108,8 +110,8 @@ var TypeBase;
         (0, debug_1.assert)(TypeBase.isInstantiable(type));
         const newInstance = TypeBase.cloneType(type);
         if (newInstance.instantiableNestingLevel === undefined) {
-            newInstance.flags &= ~1 /* Instantiable */;
-            newInstance.flags |= 2 /* Instance */;
+            newInstance.flags &= ~1 /* TypeFlags.Instantiable */;
+            newInstance.flags |= 2 /* TypeFlags.Instance */;
             delete newInstance.instantiableNestingLevel;
         }
         else {
@@ -133,8 +135,8 @@ var TypeBase;
     function cloneTypeAsInstantiable(type, cache) {
         const newInstance = TypeBase.cloneType(type);
         if (TypeBase.isInstance(type)) {
-            newInstance.flags &= ~2 /* Instance */;
-            newInstance.flags |= 1 /* Instantiable */;
+            newInstance.flags &= ~2 /* TypeFlags.Instance */;
+            newInstance.flags |= 1 /* TypeFlags.Instantiable */;
         }
         else {
             newInstance.instantiableNestingLevel =
@@ -165,7 +167,7 @@ var TypeBase;
     TypeBase.cloneForTypeAlias = cloneForTypeAlias;
     function cloneForAnnotated(type) {
         const typeClone = cloneType(type);
-        typeClone.flags |= 4 /* Annotated */;
+        typeClone.flags |= 4 /* TypeFlags.Annotated */;
         return typeClone;
     }
     TypeBase.cloneForAnnotated = cloneForAnnotated;
@@ -189,29 +191,29 @@ var TypeBase;
         return typeClone;
     }
     TypeBase.cloneForAmbiguousType = cloneForAmbiguousType;
-})(TypeBase = exports.TypeBase || (exports.TypeBase = {}));
+})(TypeBase || (exports.TypeBase = TypeBase = {}));
 var UnboundType;
 (function (UnboundType) {
     const _instance = {
-        category: 0 /* Unbound */,
-        flags: 1 /* Instantiable */ | 2 /* Instance */,
+        category: 0 /* TypeCategory.Unbound */,
+        flags: 1 /* TypeFlags.Instantiable */ | 2 /* TypeFlags.Instance */,
     };
     function create() {
         // All Unbound objects are the same, so use a shared instance.
         return _instance;
     }
     UnboundType.create = create;
-})(UnboundType = exports.UnboundType || (exports.UnboundType = {}));
+})(UnboundType || (exports.UnboundType = UnboundType = {}));
 var UnknownType;
 (function (UnknownType) {
     const _instance = {
-        category: 1 /* Unknown */,
-        flags: 1 /* Instantiable */ | 2 /* Instance */,
+        category: 1 /* TypeCategory.Unknown */,
+        flags: 1 /* TypeFlags.Instantiable */ | 2 /* TypeFlags.Instance */,
         isIncomplete: false,
     };
     const _incompleteInstance = {
-        category: 1 /* Unknown */,
-        flags: 1 /* Instantiable */ | 2 /* Instance */,
+        category: 1 /* TypeCategory.Unknown */,
+        flags: 1 /* TypeFlags.Instantiable */ | 2 /* TypeFlags.Instance */,
         isIncomplete: true,
     };
     function create(isIncomplete = false) {
@@ -220,23 +222,23 @@ var UnknownType;
     UnknownType.create = create;
     function createPossibleType(possibleType, isIncomplete) {
         const unknownWithPossibleType = {
-            category: 1 /* Unknown */,
-            flags: 1 /* Instantiable */ | 2 /* Instance */,
+            category: 1 /* TypeCategory.Unknown */,
+            flags: 1 /* TypeFlags.Instantiable */ | 2 /* TypeFlags.Instance */,
             isIncomplete,
             possibleType,
         };
         return unknownWithPossibleType;
     }
     UnknownType.createPossibleType = createPossibleType;
-})(UnknownType = exports.UnknownType || (exports.UnknownType = {}));
+})(UnknownType || (exports.UnknownType = UnknownType = {}));
 var ModuleType;
 (function (ModuleType) {
     function create(moduleName, filePath, symbolTable) {
         const newModuleType = {
-            category: 7 /* Module */,
+            category: 7 /* TypeCategory.Module */,
             fields: symbolTable || new Map(),
             loaderFields: new Map(),
-            flags: 1 /* Instantiable */ | 1 /* Instantiable */,
+            flags: 1 /* TypeFlags.Instantiable */ | 1 /* TypeFlags.Instantiable */,
             moduleName,
             filePath,
         };
@@ -265,7 +267,7 @@ var ModuleType;
         return symbol;
     }
     ModuleType.getField = getField;
-})(ModuleType = exports.ModuleType || (exports.ModuleType = {}));
+})(ModuleType || (exports.ModuleType = ModuleType = {}));
 var ClassTypeFlags;
 (function (ClassTypeFlags) {
     ClassTypeFlags[ClassTypeFlags["None"] = 0] = "None";
@@ -346,12 +348,12 @@ var ClassTypeFlags;
     ClassTypeFlags[ClassTypeFlags["SynthesizeDataClassUnsafeHash"] = 67108864] = "SynthesizeDataClassUnsafeHash";
     // Decorated with @type_check_only.
     ClassTypeFlags[ClassTypeFlags["TypeCheckOnly"] = 134217728] = "TypeCheckOnly";
-})(ClassTypeFlags = exports.ClassTypeFlags || (exports.ClassTypeFlags = {}));
+})(ClassTypeFlags || (exports.ClassTypeFlags = ClassTypeFlags = {}));
 var ClassType;
 (function (ClassType) {
     function createInstantiable(name, fullName, moduleName, filePath, flags, typeSourceId, declaredMetaclass, effectiveMetaclass, docString) {
         const newClass = {
-            category: 6 /* Class */,
+            category: 6 /* TypeCategory.Class */,
             details: {
                 name,
                 fullName,
@@ -367,7 +369,7 @@ var ClassType;
                 typeParameters: [],
                 docString,
             },
-            flags: 1 /* Instantiable */,
+            flags: 1 /* TypeFlags.Instantiable */,
         };
         return newClass;
     }
@@ -381,7 +383,7 @@ var ClassType;
             return type.cached.typeBaseInstanceType;
         }
         const newInstance = TypeBase.cloneTypeAsInstance(type, /* cache */ includeSubclasses);
-        newInstance.flags &= ~8 /* SpecialForm */;
+        newInstance.flags &= ~8 /* TypeFlags.SpecialForm */;
         if (includeSubclasses) {
             newInstance.includeSubclasses = true;
         }
@@ -394,7 +396,7 @@ var ClassType;
             return type.cached.typeBaseInstantiableType;
         }
         const newInstance = TypeBase.cloneTypeAsInstantiable(type, includeSubclasses);
-        newInstance.flags &= ~8 /* SpecialForm */;
+        newInstance.flags &= ~8 /* TypeFlags.SpecialForm */;
         if (includeSubclasses) {
             newInstance.includeSubclasses = true;
         }
@@ -572,7 +574,7 @@ var ClassType;
     }
     ClassType.isUnspecialized = isUnspecialized;
     function isSpecialBuiltIn(classType, className) {
-        if (!(classType.details.flags & 2 /* SpecialBuiltIn */) && !classType.aliasName) {
+        if (!(classType.details.flags & 2 /* ClassTypeFlags.SpecialBuiltIn */) && !classType.aliasName) {
             return false;
         }
         if (className !== undefined) {
@@ -582,7 +584,7 @@ var ClassType;
     }
     ClassType.isSpecialBuiltIn = isSpecialBuiltIn;
     function isBuiltIn(classType, className) {
-        if (!(classType.details.flags & 1 /* BuiltInClass */)) {
+        if (!(classType.details.flags & 1 /* ClassTypeFlags.BuiltInClass */)) {
             return false;
         }
         if (className !== undefined) {
@@ -598,79 +600,79 @@ var ClassType;
     }
     ClassType.derivesFromAnyOrUnknown = derivesFromAnyOrUnknown;
     function supportsAbstractMethods(classType) {
-        return !!(classType.details.flags & 1024 /* SupportsAbstractMethods */);
+        return !!(classType.details.flags & 1024 /* ClassTypeFlags.SupportsAbstractMethods */);
     }
     ClassType.supportsAbstractMethods = supportsAbstractMethods;
     function isDataClass(classType) {
-        return !!(classType.details.flags & 4 /* DataClass */);
+        return !!(classType.details.flags & 4 /* ClassTypeFlags.DataClass */);
     }
     ClassType.isDataClass = isDataClass;
     function isSkipSynthesizedDataClassInit(classType) {
-        return !!(classType.details.flags & 16 /* SkipSynthesizedDataClassInit */);
+        return !!(classType.details.flags & 16 /* ClassTypeFlags.SkipSynthesizedDataClassInit */);
     }
     ClassType.isSkipSynthesizedDataClassInit = isSkipSynthesizedDataClassInit;
     function isSkipSynthesizedDataClassEq(classType) {
-        return !!(classType.details.flags & 32 /* SkipSynthesizedDataClassEq */);
+        return !!(classType.details.flags & 32 /* ClassTypeFlags.SkipSynthesizedDataClassEq */);
     }
     ClassType.isSkipSynthesizedDataClassEq = isSkipSynthesizedDataClassEq;
     function isFrozenDataClass(classType) {
-        return !!(classType.details.flags & 8 /* FrozenDataClass */);
+        return !!(classType.details.flags & 8 /* ClassTypeFlags.FrozenDataClass */);
     }
     ClassType.isFrozenDataClass = isFrozenDataClass;
     function isSynthesizedDataclassOrder(classType) {
-        return !!(classType.details.flags & 64 /* SynthesizedDataClassOrder */);
+        return !!(classType.details.flags & 64 /* ClassTypeFlags.SynthesizedDataClassOrder */);
     }
     ClassType.isSynthesizedDataclassOrder = isSynthesizedDataclassOrder;
     function isDataClassKeywordOnlyParams(classType) {
-        return !!(classType.details.flags & 2097152 /* DataClassKeywordOnlyParams */);
+        return !!(classType.details.flags & 2097152 /* ClassTypeFlags.DataClassKeywordOnlyParams */);
     }
     ClassType.isDataClassKeywordOnlyParams = isDataClassKeywordOnlyParams;
     function isGeneratedDataClassSlots(classType) {
-        return !!(classType.details.flags & 33554432 /* GenerateDataClassSlots */);
+        return !!(classType.details.flags & 33554432 /* ClassTypeFlags.GenerateDataClassSlots */);
     }
     ClassType.isGeneratedDataClassSlots = isGeneratedDataClassSlots;
     function isSynthesizeDataClassUnsafeHash(classType) {
-        return !!(classType.details.flags & 67108864 /* SynthesizeDataClassUnsafeHash */);
+        return !!(classType.details.flags & 67108864 /* ClassTypeFlags.SynthesizeDataClassUnsafeHash */);
     }
     ClassType.isSynthesizeDataClassUnsafeHash = isSynthesizeDataClassUnsafeHash;
     function isTypeCheckOnly(classType) {
-        return !!(classType.details.flags & 134217728 /* TypeCheckOnly */);
+        return !!(classType.details.flags & 134217728 /* ClassTypeFlags.TypeCheckOnly */);
     }
     ClassType.isTypeCheckOnly = isTypeCheckOnly;
     function isTypedDictClass(classType) {
-        return !!(classType.details.flags & 128 /* TypedDictClass */);
+        return !!(classType.details.flags & 128 /* ClassTypeFlags.TypedDictClass */);
     }
     ClassType.isTypedDictClass = isTypedDictClass;
     function isCanOmitDictValues(classType) {
-        return !!(classType.details.flags & 256 /* CanOmitDictValues */);
+        return !!(classType.details.flags & 256 /* ClassTypeFlags.CanOmitDictValues */);
     }
     ClassType.isCanOmitDictValues = isCanOmitDictValues;
     function isEnumClass(classType) {
-        return !!(classType.details.flags & 1048576 /* EnumClass */);
+        return !!(classType.details.flags & 1048576 /* ClassTypeFlags.EnumClass */);
     }
     ClassType.isEnumClass = isEnumClass;
     function isPropertyClass(classType) {
-        return !!(classType.details.flags & 2048 /* PropertyClass */);
+        return !!(classType.details.flags & 2048 /* ClassTypeFlags.PropertyClass */);
     }
     ClassType.isPropertyClass = isPropertyClass;
     function isClassProperty(classType) {
-        return !!(classType.details.flags & 4194304 /* ClassProperty */);
+        return !!(classType.details.flags & 4194304 /* ClassTypeFlags.ClassProperty */);
     }
     ClassType.isClassProperty = isClassProperty;
     function isFinal(classType) {
-        return !!(classType.details.flags & 4096 /* Final */);
+        return !!(classType.details.flags & 4096 /* ClassTypeFlags.Final */);
     }
     ClassType.isFinal = isFinal;
     function isProtocolClass(classType) {
-        return !!(classType.details.flags & 8192 /* ProtocolClass */);
+        return !!(classType.details.flags & 8192 /* ClassTypeFlags.ProtocolClass */);
     }
     ClassType.isProtocolClass = isProtocolClass;
     function isDefinedInStub(classType) {
-        return !!(classType.details.flags & 8388608 /* DefinedInStub */);
+        return !!(classType.details.flags & 8388608 /* ClassTypeFlags.DefinedInStub */);
     }
     ClassType.isDefinedInStub = isDefinedInStub;
     function isPseudoGenericClass(classType) {
-        return !!(classType.details.flags & 16384 /* PseudoGenericClass */);
+        return !!(classType.details.flags & 16384 /* ClassTypeFlags.PseudoGenericClass */);
     }
     ClassType.isPseudoGenericClass = isPseudoGenericClass;
     function getDataClassEntries(classType) {
@@ -678,27 +680,27 @@ var ClassType;
     }
     ClassType.getDataClassEntries = getDataClassEntries;
     function isRuntimeCheckable(classType) {
-        return !!(classType.details.flags & 32768 /* RuntimeCheckable */);
+        return !!(classType.details.flags & 32768 /* ClassTypeFlags.RuntimeCheckable */);
     }
     ClassType.isRuntimeCheckable = isRuntimeCheckable;
     function isTypingExtensionClass(classType) {
-        return !!(classType.details.flags & 65536 /* TypingExtensionClass */);
+        return !!(classType.details.flags & 65536 /* ClassTypeFlags.TypingExtensionClass */);
     }
     ClassType.isTypingExtensionClass = isTypingExtensionClass;
     function isPartiallyEvaluated(classType) {
-        return !!(classType.details.flags & 131072 /* PartiallyEvaluated */);
+        return !!(classType.details.flags & 131072 /* ClassTypeFlags.PartiallyEvaluated */);
     }
     ClassType.isPartiallyEvaluated = isPartiallyEvaluated;
     function hasCustomClassGetItem(classType) {
-        return !!(classType.details.flags & 262144 /* HasCustomClassGetItem */);
+        return !!(classType.details.flags & 262144 /* ClassTypeFlags.HasCustomClassGetItem */);
     }
     ClassType.hasCustomClassGetItem = hasCustomClassGetItem;
     function isTupleClass(classType) {
-        return !!(classType.details.flags & 524288 /* TupleClass */);
+        return !!(classType.details.flags & 524288 /* ClassTypeFlags.TupleClass */);
     }
     ClassType.isTupleClass = isTupleClass;
     function isReadOnlyInstanceVariables(classType) {
-        return !!(classType.details.flags & 16777216 /* ReadOnlyInstanceVariables */);
+        return !!(classType.details.flags & 16777216 /* ClassTypeFlags.ReadOnlyInstanceVariables */);
     }
     ClassType.isReadOnlyInstanceVariables = isReadOnlyInstanceVariables;
     function getTypeParameters(classType) {
@@ -829,15 +831,15 @@ var ClassType;
         return classType.details.mro.slice(0).reverse();
     }
     ClassType.getReverseMro = getReverseMro;
-})(ClassType = exports.ClassType || (exports.ClassType = {}));
+})(ClassType || (exports.ClassType = ClassType = {}));
 function isPositionOnlySeparator(param) {
     // A simple parameter with no name is treated as a "/" separator.
-    return param.category === 0 /* Simple */ && !param.name;
+    return param.category === 0 /* ParameterCategory.Simple */ && !param.name;
 }
 exports.isPositionOnlySeparator = isPositionOnlySeparator;
 function isKeywordOnlySeparator(param) {
     // An *args parameter with no name is treated as a "*" separator.
-    return param.category === 1 /* ArgsList */ && !param.name;
+    return param.category === 1 /* ParameterCategory.ArgsList */ && !param.name;
 }
 exports.isKeywordOnlySeparator = isKeywordOnlySeparator;
 var FunctionTypeFlags;
@@ -891,24 +893,24 @@ var FunctionTypeFlags;
     FunctionTypeFlags[FunctionTypeFlags["PartiallyEvaluated"] = 131072] = "PartiallyEvaluated";
     // Decorated with @override as defined in PEP 698.
     FunctionTypeFlags[FunctionTypeFlags["Overridden"] = 262144] = "Overridden";
-})(FunctionTypeFlags = exports.FunctionTypeFlags || (exports.FunctionTypeFlags = {}));
+})(FunctionTypeFlags || (exports.FunctionTypeFlags = FunctionTypeFlags = {}));
 var FunctionType;
 (function (FunctionType) {
     function createInstance(name, fullName, moduleName, functionFlags, docString) {
-        return create(name, fullName, moduleName, functionFlags, 2 /* Instance */, docString);
+        return create(name, fullName, moduleName, functionFlags, 2 /* TypeFlags.Instance */, docString);
     }
     FunctionType.createInstance = createInstance;
     function createInstantiable(functionFlags, docString) {
-        return create('', '', '', functionFlags, 1 /* Instantiable */, docString);
+        return create('', '', '', functionFlags, 1 /* TypeFlags.Instantiable */, docString);
     }
     FunctionType.createInstantiable = createInstantiable;
-    function createSynthesizedInstance(name, additionalFlags = 0 /* None */) {
-        return create(name, '', '', additionalFlags | 64 /* SynthesizedMethod */, 2 /* Instance */);
+    function createSynthesizedInstance(name, additionalFlags = 0 /* FunctionTypeFlags.None */) {
+        return create(name, '', '', additionalFlags | 64 /* FunctionTypeFlags.SynthesizedMethod */, 2 /* TypeFlags.Instance */);
     }
     FunctionType.createSynthesizedInstance = createSynthesizedInstance;
     function create(name, fullName, moduleName, functionFlags, typeFlags, docString) {
         const newFunctionType = {
-            category: 4 /* Function */,
+            category: 4 /* TypeCategory.Function */,
             details: {
                 name,
                 fullName,
@@ -932,7 +934,7 @@ var FunctionType;
         newFunction.preBoundFlags = newFunction.details.flags;
         if (stripFirstParam) {
             if (type.details.parameters.length > 0) {
-                if (type.details.parameters[0].category === 0 /* Simple */) {
+                if (type.details.parameters[0].category === 0 /* ParameterCategory.Simple */) {
                     if (type.details.parameters.length > 0 && !type.details.parameters[0].isTypeInferred) {
                         // Stash away the effective type of the first parameter if it
                         // wasn't synthesized.
@@ -946,8 +948,8 @@ var FunctionType;
             }
             // If we strip off the first parameter, this is no longer an
             // instance method or class method.
-            newFunction.details.flags &= ~(1 /* ConstructorMethod */ | 2 /* ClassMethod */);
-            newFunction.details.flags |= 4 /* StaticMethod */;
+            newFunction.details.flags &= ~(1 /* FunctionTypeFlags.ConstructorMethod */ | 2 /* FunctionTypeFlags.ClassMethod */);
+            newFunction.details.flags |= 4 /* FunctionTypeFlags.StaticMethod */;
         }
         if (type.typeAliasInfo !== undefined) {
             newFunction.typeAliasInfo = type.typeAliasInfo;
@@ -974,7 +976,7 @@ var FunctionType;
             return type.cached.typeBaseInstanceType;
         }
         const newInstance = TypeBase.cloneTypeAsInstance(type, /* cache */ true);
-        newInstance.flags &= ~8 /* SpecialForm */;
+        newInstance.flags &= ~8 /* TypeFlags.SpecialForm */;
         return newInstance;
     }
     FunctionType.cloneAsInstance = cloneAsInstance;
@@ -984,7 +986,7 @@ var FunctionType;
             return type.cached.typeBaseInstantiableType;
         }
         const newInstance = TypeBase.cloneTypeAsInstantiable(type, /* cache */ true);
-        newInstance.flags &= ~8 /* SpecialForm */;
+        newInstance.flags &= ~8 /* TypeFlags.SpecialForm */;
         return newInstance;
     }
     FunctionType.cloneAsInstantiable = cloneAsInstantiable;
@@ -1036,14 +1038,14 @@ var FunctionType;
             }
             newFunction.details.flags =
                 (paramSpecValue.details.flags &
-                    (2 /* ClassMethod */ |
-                        4 /* StaticMethod */ |
-                        1 /* ConstructorMethod */ |
-                        256 /* Overloaded */ |
-                        32768 /* SkipArgsKwargsCompatibilityCheck */)) |
-                    64 /* SynthesizedMethod */;
+                    (2 /* FunctionTypeFlags.ClassMethod */ |
+                        4 /* FunctionTypeFlags.StaticMethod */ |
+                        1 /* FunctionTypeFlags.ConstructorMethod */ |
+                        256 /* FunctionTypeFlags.Overloaded */ |
+                        32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */)) |
+                    64 /* FunctionTypeFlags.SynthesizedMethod */;
             if (FunctionType.isParamSpecValue(type)) {
-                newFunction.details.flags |= 65536 /* ParamSpecValue */;
+                newFunction.details.flags |= 65536 /* FunctionTypeFlags.ParamSpecValue */;
             }
             // Update the specialized parameter types as well.
             if (type.specializedTypes) {
@@ -1116,9 +1118,9 @@ var FunctionType;
             newFunction.specializedTypes.parameterTypes = newFunction.specializedTypes.parameterTypes.slice(0, newFunction.specializedTypes.parameterTypes.length - 2);
         }
         // Update the flags of the function.
-        newFunction.details.flags &= ~32768 /* SkipArgsKwargsCompatibilityCheck */;
-        if (paramSpecValue.details.flags & 32768 /* SkipArgsKwargsCompatibilityCheck */) {
-            newFunction.details.flags |= 32768 /* SkipArgsKwargsCompatibilityCheck */;
+        newFunction.details.flags &= ~32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */;
+        if (paramSpecValue.details.flags & 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */) {
+            newFunction.details.flags |= 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */;
         }
         // If there is a position-only separator in the captured param spec signature,
         // remove the position-only separator in the existing signature. Otherwise,
@@ -1185,13 +1187,13 @@ var FunctionType;
     function getDefaultParameters(useUnknown = false) {
         return [
             {
-                category: 1 /* ArgsList */,
+                category: 1 /* ParameterCategory.ArgsList */,
                 name: 'args',
                 type: useUnknown ? UnknownType.create() : AnyType.create(),
                 hasDeclaredType: !useUnknown,
             },
             {
-                category: 2 /* KwargsDict */,
+                category: 2 /* ParameterCategory.KwargsDict */,
                 name: 'kwargs',
                 type: useUnknown ? UnknownType.create() : AnyType.create(),
                 hasDeclaredType: !useUnknown,
@@ -1209,13 +1211,13 @@ var FunctionType;
             if (!param.name) {
                 continue;
             }
-            if (param.category === 0 /* Simple */) {
+            if (param.category === 0 /* ParameterCategory.Simple */) {
                 return false;
             }
-            else if (param.category === 1 /* ArgsList */) {
+            else if (param.category === 1 /* ParameterCategory.ArgsList */) {
                 sawArgs = true;
             }
-            else if (param.category === 2 /* KwargsDict */) {
+            else if (param.category === 2 /* ParameterCategory.KwargsDict */) {
                 sawKwargs = true;
             }
             if (!isAnyOrUnknown(FunctionType.getEffectiveParameterType(functionType, i))) {
@@ -1227,82 +1229,82 @@ var FunctionType;
     FunctionType.hasDefaultParameters = hasDefaultParameters;
     function isInstanceMethod(type) {
         return ((type.details.flags &
-            (1 /* ConstructorMethod */ |
-                4 /* StaticMethod */ |
-                2 /* ClassMethod */)) ===
+            (1 /* FunctionTypeFlags.ConstructorMethod */ |
+                4 /* FunctionTypeFlags.StaticMethod */ |
+                2 /* FunctionTypeFlags.ClassMethod */)) ===
             0);
     }
     FunctionType.isInstanceMethod = isInstanceMethod;
     function isConstructorMethod(type) {
-        return (type.details.flags & 1 /* ConstructorMethod */) !== 0;
+        return (type.details.flags & 1 /* FunctionTypeFlags.ConstructorMethod */) !== 0;
     }
     FunctionType.isConstructorMethod = isConstructorMethod;
     function isStaticMethod(type) {
-        return (type.details.flags & 4 /* StaticMethod */) !== 0;
+        return (type.details.flags & 4 /* FunctionTypeFlags.StaticMethod */) !== 0;
     }
     FunctionType.isStaticMethod = isStaticMethod;
     function isClassMethod(type) {
-        return (type.details.flags & 2 /* ClassMethod */) !== 0;
+        return (type.details.flags & 2 /* FunctionTypeFlags.ClassMethod */) !== 0;
     }
     FunctionType.isClassMethod = isClassMethod;
     function isAbstractMethod(type) {
-        return (type.details.flags & 8 /* AbstractMethod */) !== 0;
+        return (type.details.flags & 8 /* FunctionTypeFlags.AbstractMethod */) !== 0;
     }
     FunctionType.isAbstractMethod = isAbstractMethod;
     function isGenerator(type) {
-        return (type.details.flags & 16 /* Generator */) !== 0;
+        return (type.details.flags & 16 /* FunctionTypeFlags.Generator */) !== 0;
     }
     FunctionType.isGenerator = isGenerator;
     function isSynthesizedMethod(type) {
-        return (type.details.flags & 64 /* SynthesizedMethod */) !== 0;
+        return (type.details.flags & 64 /* FunctionTypeFlags.SynthesizedMethod */) !== 0;
     }
     FunctionType.isSynthesizedMethod = isSynthesizedMethod;
     function isTypeCheckOnly(type) {
-        return (type.details.flags & 128 /* TypeCheckOnly */) !== 0;
+        return (type.details.flags & 128 /* FunctionTypeFlags.TypeCheckOnly */) !== 0;
     }
     FunctionType.isTypeCheckOnly = isTypeCheckOnly;
     function isOverloaded(type) {
-        return (type.details.flags & 256 /* Overloaded */) !== 0;
+        return (type.details.flags & 256 /* FunctionTypeFlags.Overloaded */) !== 0;
     }
     FunctionType.isOverloaded = isOverloaded;
     function isDefaultParameterCheckDisabled(type) {
-        return (type.details.flags & 32 /* DisableDefaultChecks */) !== 0;
+        return (type.details.flags & 32 /* FunctionTypeFlags.DisableDefaultChecks */) !== 0;
     }
     FunctionType.isDefaultParameterCheckDisabled = isDefaultParameterCheckDisabled;
     function isAsync(type) {
-        return (type.details.flags & 512 /* Async */) !== 0;
+        return (type.details.flags & 512 /* FunctionTypeFlags.Async */) !== 0;
     }
     FunctionType.isAsync = isAsync;
     function isStubDefinition(type) {
-        return (type.details.flags & 2048 /* StubDefinition */) !== 0;
+        return (type.details.flags & 2048 /* FunctionTypeFlags.StubDefinition */) !== 0;
     }
     FunctionType.isStubDefinition = isStubDefinition;
     function isPyTypedDefinition(type) {
-        return (type.details.flags & 4096 /* PyTypedDefinition */) !== 0;
+        return (type.details.flags & 4096 /* FunctionTypeFlags.PyTypedDefinition */) !== 0;
     }
     FunctionType.isPyTypedDefinition = isPyTypedDefinition;
     function isFinal(type) {
-        return (type.details.flags & 8192 /* Final */) !== 0;
+        return (type.details.flags & 8192 /* FunctionTypeFlags.Final */) !== 0;
     }
     FunctionType.isFinal = isFinal;
     function hasUnannotatedParams(type) {
-        return (type.details.flags & 16384 /* UnannotatedParams */) !== 0;
+        return (type.details.flags & 16384 /* FunctionTypeFlags.UnannotatedParams */) !== 0;
     }
     FunctionType.hasUnannotatedParams = hasUnannotatedParams;
     function shouldSkipArgsKwargsCompatibilityCheck(type) {
-        return (type.details.flags & 32768 /* SkipArgsKwargsCompatibilityCheck */) !== 0;
+        return (type.details.flags & 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */) !== 0;
     }
     FunctionType.shouldSkipArgsKwargsCompatibilityCheck = shouldSkipArgsKwargsCompatibilityCheck;
     function isParamSpecValue(type) {
-        return (type.details.flags & 65536 /* ParamSpecValue */) !== 0;
+        return (type.details.flags & 65536 /* FunctionTypeFlags.ParamSpecValue */) !== 0;
     }
     FunctionType.isParamSpecValue = isParamSpecValue;
     function isPartiallyEvaluated(type) {
-        return !!(type.details.flags & 131072 /* PartiallyEvaluated */);
+        return !!(type.details.flags & 131072 /* FunctionTypeFlags.PartiallyEvaluated */);
     }
     FunctionType.isPartiallyEvaluated = isPartiallyEvaluated;
     function isOverridden(type) {
-        return !!(type.details.flags & 262144 /* Overridden */);
+        return !!(type.details.flags & 262144 /* FunctionTypeFlags.Overridden */);
     }
     FunctionType.isOverridden = isOverridden;
     function getEffectiveParameterType(type, index) {
@@ -1332,20 +1334,28 @@ var FunctionType;
         }
     }
     FunctionType.addParameter = addParameter;
-    function getSpecializedReturnType(type) {
-        return type.specializedTypes && type.specializedTypes.returnType
-            ? type.specializedTypes.returnType
-            : type.details.declaredReturnType;
+    function getSpecializedReturnType(type, includeInferred = true) {
+        var _a;
+        if ((_a = type.specializedTypes) === null || _a === void 0 ? void 0 : _a.returnType) {
+            return type.specializedTypes.returnType;
+        }
+        if (type.details.declaredReturnType) {
+            return type.details.declaredReturnType;
+        }
+        if (includeInferred) {
+            return type.inferredReturnType;
+        }
+        return undefined;
     }
     FunctionType.getSpecializedReturnType = getSpecializedReturnType;
-})(FunctionType = exports.FunctionType || (exports.FunctionType = {}));
+})(FunctionType || (exports.FunctionType = FunctionType = {}));
 var OverloadedFunctionType;
 (function (OverloadedFunctionType) {
     function create(overloads) {
         const newType = {
-            category: 5 /* OverloadedFunction */,
+            category: 5 /* TypeCategory.OverloadedFunction */,
             overloads: [],
-            flags: 2 /* Instance */,
+            flags: 2 /* TypeFlags.Instance */,
         };
         overloads.forEach((overload) => {
             OverloadedFunctionType.addOverload(newType, overload);
@@ -1367,17 +1377,17 @@ var OverloadedFunctionType;
         return type.overloads.find((func) => !FunctionType.isOverloaded(func));
     }
     OverloadedFunctionType.getImplementation = getImplementation;
-})(OverloadedFunctionType = exports.OverloadedFunctionType || (exports.OverloadedFunctionType = {}));
+})(OverloadedFunctionType || (exports.OverloadedFunctionType = OverloadedFunctionType = {}));
 var NeverType;
 (function (NeverType) {
     const _neverInstance = {
-        category: 3 /* Never */,
-        flags: 2 /* Instance */ | 1 /* Instantiable */,
+        category: 3 /* TypeCategory.Never */,
+        flags: 2 /* TypeFlags.Instance */ | 1 /* TypeFlags.Instantiable */,
         isNoReturn: false,
     };
     const _noReturnInstance = {
-        category: 3 /* Never */,
-        flags: 2 /* Instance */ | 1 /* Instantiable */,
+        category: 3 /* TypeCategory.Never */,
+        flags: 2 /* TypeFlags.Instance */ | 1 /* TypeFlags.Instantiable */,
         isNoReturn: true,
     };
     function createNever() {
@@ -1388,23 +1398,23 @@ var NeverType;
         return _noReturnInstance;
     }
     NeverType.createNoReturn = createNoReturn;
-})(NeverType = exports.NeverType || (exports.NeverType = {}));
+})(NeverType || (exports.NeverType = NeverType = {}));
 var AnyType;
 (function (AnyType) {
     const _anyInstanceSpecialForm = {
-        category: 2 /* Any */,
+        category: 2 /* TypeCategory.Any */,
         isEllipsis: false,
-        flags: 2 /* Instance */ | 1 /* Instantiable */ | 8 /* SpecialForm */,
+        flags: 2 /* TypeFlags.Instance */ | 1 /* TypeFlags.Instantiable */ | 8 /* TypeFlags.SpecialForm */,
     };
     const _anyInstance = {
-        category: 2 /* Any */,
+        category: 2 /* TypeCategory.Any */,
         isEllipsis: false,
-        flags: 2 /* Instance */ | 1 /* Instantiable */,
+        flags: 2 /* TypeFlags.Instance */ | 1 /* TypeFlags.Instantiable */,
     };
     const _ellipsisInstance = {
-        category: 2 /* Any */,
+        category: 2 /* TypeCategory.Any */,
         isEllipsis: true,
-        flags: 2 /* Instance */ | 1 /* Instantiable */,
+        flags: 2 /* TypeFlags.Instance */ | 1 /* TypeFlags.Instantiable */,
     };
     function create(isEllipsis = false) {
         return isEllipsis ? _ellipsisInstance : _anyInstance;
@@ -1414,7 +1424,7 @@ var AnyType;
         return _anyInstanceSpecialForm;
     }
     AnyType.createSpecialForm = createSpecialForm;
-})(AnyType = exports.AnyType || (exports.AnyType = {}));
+})(AnyType || (exports.AnyType = AnyType = {}));
 (function (AnyType) {
     function convertToInstance(type) {
         // Remove the "special form" flag if it's set. Otherwise
@@ -1425,7 +1435,7 @@ var AnyType;
         return type;
     }
     AnyType.convertToInstance = convertToInstance;
-})(AnyType = exports.AnyType || (exports.AnyType = {}));
+})(AnyType || (exports.AnyType = AnyType = {}));
 var TypeCondition;
 (function (TypeCondition) {
     function combine(conditions1, conditions2) {
@@ -1496,14 +1506,14 @@ var TypeCondition;
         return true;
     }
     TypeCondition.isCompatible = isCompatible;
-})(TypeCondition = exports.TypeCondition || (exports.TypeCondition = {}));
+})(TypeCondition || (exports.TypeCondition = TypeCondition = {}));
 var UnionType;
 (function (UnionType) {
     function create() {
         const newUnionType = {
-            category: 8 /* Union */,
+            category: 8 /* TypeCategory.Union */,
             subtypes: [],
-            flags: 2 /* Instance */ | 1 /* Instantiable */,
+            flags: 2 /* TypeFlags.Instance */ | 1 /* TypeFlags.Instantiable */,
         };
         return newUnionType;
     }
@@ -1574,7 +1584,7 @@ var UnionType;
     }
     UnionType.containsType = containsType;
     function addTypeAliasSource(unionType, typeAliasSource) {
-        if (typeAliasSource.category === 8 /* Union */) {
+        if (typeAliasSource.category === 8 /* TypeCategory.Union */) {
             const sourcesToAdd = typeAliasSource.typeAliasInfo ? [typeAliasSource] : typeAliasSource.typeAliasSources;
             if (sourcesToAdd) {
                 if (!unionType.typeAliasSources) {
@@ -1587,7 +1597,7 @@ var UnionType;
         }
     }
     UnionType.addTypeAliasSource = addTypeAliasSource;
-})(UnionType = exports.UnionType || (exports.UnionType = {}));
+})(UnionType || (exports.UnionType = UnionType = {}));
 var Variance;
 (function (Variance) {
     Variance[Variance["Auto"] = 0] = "Auto";
@@ -1595,21 +1605,21 @@ var Variance;
     Variance[Variance["Invariant"] = 2] = "Invariant";
     Variance[Variance["Covariant"] = 3] = "Covariant";
     Variance[Variance["Contravariant"] = 4] = "Contravariant";
-})(Variance = exports.Variance || (exports.Variance = {}));
+})(Variance || (exports.Variance = Variance = {}));
 var TypeVarScopeType;
 (function (TypeVarScopeType) {
     TypeVarScopeType[TypeVarScopeType["Class"] = 0] = "Class";
     TypeVarScopeType[TypeVarScopeType["Function"] = 1] = "Function";
     TypeVarScopeType[TypeVarScopeType["TypeAlias"] = 2] = "TypeAlias";
-})(TypeVarScopeType = exports.TypeVarScopeType || (exports.TypeVarScopeType = {}));
+})(TypeVarScopeType || (exports.TypeVarScopeType = TypeVarScopeType = {}));
 var TypeVarType;
 (function (TypeVarType) {
     function createInstance(name) {
-        return create(name, /* isParamSpec */ false, 2 /* Instance */);
+        return create(name, /* isParamSpec */ false, 2 /* TypeFlags.Instance */);
     }
     TypeVarType.createInstance = createInstance;
     function createInstantiable(name, isParamSpec = false, runtimeClass) {
-        return create(name, isParamSpec, 1 /* Instantiable */, runtimeClass);
+        return create(name, isParamSpec, 1 /* TypeFlags.Instantiable */, runtimeClass);
     }
     TypeVarType.createInstantiable = createInstantiable;
     function cloneAsInstance(type) {
@@ -1619,7 +1629,7 @@ var TypeVarType;
             return type.cached.typeBaseInstanceType;
         }
         const newInstance = TypeBase.cloneTypeAsInstance(type, /* cache */ true);
-        newInstance.flags &= ~8 /* SpecialForm */;
+        newInstance.flags &= ~8 /* TypeFlags.SpecialForm */;
         return newInstance;
     }
     TypeVarType.cloneAsInstance = cloneAsInstance;
@@ -1629,7 +1639,7 @@ var TypeVarType;
             return type.cached.typeBaseInstantiableType;
         }
         const newInstance = TypeBase.cloneTypeAsInstantiable(type, /* cache */ true);
-        newInstance.flags &= ~8 /* SpecialForm */;
+        newInstance.flags &= ~8 /* TypeFlags.SpecialForm */;
         return newInstance;
     }
     TypeVarType.cloneAsInstantiable = cloneAsInstantiable;
@@ -1675,17 +1685,17 @@ var TypeVarType;
         if (type.details.isParamSpec || type.details.isVariadic) {
             return type;
         }
-        if (type.details.declaredVariance === 0 /* Auto */) {
+        if (type.details.declaredVariance === 0 /* Variance.Auto */) {
             return type;
         }
-        if (type.details.declaredVariance === 2 /* Invariant */) {
+        if (type.details.declaredVariance === 2 /* Variance.Invariant */) {
             if (type.details.boundType === undefined && type.details.constraints.length === 0) {
                 return type;
             }
         }
         const newInstance = TypeBase.cloneType(type);
         newInstance.details = { ...newInstance.details };
-        newInstance.details.declaredVariance = 2 /* Invariant */;
+        newInstance.details.declaredVariance = 2 /* Variance.Invariant */;
         newInstance.details.boundType = undefined;
         newInstance.details.constraints = [];
         return newInstance;
@@ -1730,11 +1740,11 @@ var TypeVarType;
     TypeVarType.makeNameWithScope = makeNameWithScope;
     function create(name, isParamSpec, typeFlags, runtimeClass) {
         const newTypeVarType = {
-            category: 9 /* TypeVar */,
+            category: 9 /* TypeCategory.TypeVar */,
             details: {
                 name,
                 constraints: [],
-                declaredVariance: 2 /* Invariant */,
+                declaredVariance: 2 /* Variance.Invariant */,
                 isParamSpec,
                 isVariadic: false,
                 isSynthesized: false,
@@ -1764,11 +1774,11 @@ var TypeVarType;
         var _a;
         const variance = (_a = type.computedVariance) !== null && _a !== void 0 ? _a : type.details.declaredVariance;
         // By this point, the variance should have been inferred.
-        (0, debug_1.assert)(variance !== 0 /* Auto */, 'Expected variance to be inferred');
+        (0, debug_1.assert)(variance !== 0 /* Variance.Auto */, 'Expected variance to be inferred');
         // If we're in the process of computing variance, it will still be
         // unknown. Default to covariant in this case.
-        if (variance === 1 /* Unknown */) {
-            return 3 /* Covariant */;
+        if (variance === 1 /* Variance.Unknown */) {
+            return 3 /* Variance.Covariant */;
         }
         return variance;
     }
@@ -1779,21 +1789,21 @@ var TypeVarType;
         return !!type.details.recursiveTypeAliasName && !type.details.boundType;
     }
     TypeVarType.isTypeAliasPlaceholder = isTypeAliasPlaceholder;
-})(TypeVarType = exports.TypeVarType || (exports.TypeVarType = {}));
+})(TypeVarType || (exports.TypeVarType = TypeVarType = {}));
 function isNever(type) {
-    return type.category === 3 /* Never */;
+    return type.category === 3 /* TypeCategory.Never */;
 }
 exports.isNever = isNever;
 function isAny(type) {
-    return type.category === 2 /* Any */;
+    return type.category === 2 /* TypeCategory.Any */;
 }
 exports.isAny = isAny;
 function isUnknown(type) {
-    return type.category === 1 /* Unknown */;
+    return type.category === 1 /* TypeCategory.Unknown */;
 }
 exports.isUnknown = isUnknown;
 function isAnyOrUnknown(type) {
-    if (type.category === 2 /* Any */ || type.category === 1 /* Unknown */) {
+    if (type.category === 2 /* TypeCategory.Any */ || type.category === 1 /* TypeCategory.Unknown */) {
         return true;
     }
     if (isUnion(type)) {
@@ -1803,11 +1813,11 @@ function isAnyOrUnknown(type) {
 }
 exports.isAnyOrUnknown = isAnyOrUnknown;
 function isUnbound(type) {
-    return type.category === 0 /* Unbound */;
+    return type.category === 0 /* TypeCategory.Unbound */;
 }
 exports.isUnbound = isUnbound;
 function isUnion(type) {
-    return type.category === 8 /* Union */;
+    return type.category === 8 /* TypeCategory.Union */;
 }
 exports.isUnion = isUnion;
 function isPossiblyUnbound(type) {
@@ -1821,31 +1831,31 @@ function isPossiblyUnbound(type) {
 }
 exports.isPossiblyUnbound = isPossiblyUnbound;
 function isClass(type) {
-    return type.category === 6 /* Class */;
+    return type.category === 6 /* TypeCategory.Class */;
 }
 exports.isClass = isClass;
 function isInstantiableClass(type) {
-    return type.category === 6 /* Class */ && TypeBase.isInstantiable(type);
+    return type.category === 6 /* TypeCategory.Class */ && TypeBase.isInstantiable(type);
 }
 exports.isInstantiableClass = isInstantiableClass;
 function isClassInstance(type) {
-    return type.category === 6 /* Class */ && TypeBase.isInstance(type);
+    return type.category === 6 /* TypeCategory.Class */ && TypeBase.isInstance(type);
 }
 exports.isClassInstance = isClassInstance;
 function isModule(type) {
-    return type.category === 7 /* Module */;
+    return type.category === 7 /* TypeCategory.Module */;
 }
 exports.isModule = isModule;
 function isTypeVar(type) {
-    return type.category === 9 /* TypeVar */;
+    return type.category === 9 /* TypeCategory.TypeVar */;
 }
 exports.isTypeVar = isTypeVar;
 function isVariadicTypeVar(type) {
-    return type.category === 9 /* TypeVar */ && type.details.isVariadic;
+    return type.category === 9 /* TypeCategory.TypeVar */ && type.details.isVariadic;
 }
 exports.isVariadicTypeVar = isVariadicTypeVar;
 function isUnpackedVariadicTypeVar(type) {
-    return (type.category === 9 /* TypeVar */ &&
+    return (type.category === 9 /* TypeCategory.TypeVar */ &&
         type.details.isVariadic &&
         !!type.isVariadicUnpacked &&
         !type.isVariadicInUnion);
@@ -1863,15 +1873,15 @@ function isUnpacked(type) {
 }
 exports.isUnpacked = isUnpacked;
 function isParamSpec(type) {
-    return type.category === 9 /* TypeVar */ && type.details.isParamSpec;
+    return type.category === 9 /* TypeCategory.TypeVar */ && type.details.isParamSpec;
 }
 exports.isParamSpec = isParamSpec;
 function isFunction(type) {
-    return type.category === 4 /* Function */;
+    return type.category === 4 /* TypeCategory.Function */;
 }
 exports.isFunction = isFunction;
 function isOverloadedFunction(type) {
-    return type.category === 5 /* OverloadedFunction */;
+    return type.category === 5 /* TypeCategory.OverloadedFunction */;
 }
 exports.isOverloadedFunction = isOverloadedFunction;
 function getTypeAliasInfo(type) {
@@ -1897,10 +1907,10 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
     }
     if (type1.category !== type2.category) {
         if (options.treatAnySameAsUnknown) {
-            if (type1.category === 2 /* Any */ && type2.category === 1 /* Unknown */) {
+            if (type1.category === 2 /* TypeCategory.Any */ && type2.category === 1 /* TypeCategory.Unknown */) {
                 return true;
             }
-            if (type1.category === 1 /* Unknown */ && type2.category === 2 /* Any */) {
+            if (type1.category === 1 /* TypeCategory.Unknown */ && type2.category === 2 /* TypeCategory.Any */) {
                 return true;
             }
         }
@@ -1916,8 +1926,8 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
         }
         else {
             // By default, we don't care about the Annotated flag.
-            type1Flags &= ~4 /* Annotated */;
-            type2Flags &= ~4 /* Annotated */;
+            type1Flags &= ~4 /* TypeFlags.Annotated */;
+            type2Flags &= ~4 /* TypeFlags.Annotated */;
         }
         if (type1Flags !== type2Flags) {
             return false;
@@ -1928,7 +1938,7 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
     }
     recursionCount++;
     switch (type1.category) {
-        case 6 /* Class */: {
+        case 6 /* TypeCategory.Class */: {
             const classType2 = type2;
             // If the details are not the same it's not the same class.
             if (!ClassType.isSameGenericClass(type1, classType2, recursionCount)) {
@@ -1979,7 +1989,7 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
             }
             return true;
         }
-        case 4 /* Function */: {
+        case 4 /* TypeCategory.Function */: {
             // Make sure the parameter counts match.
             const functionType2 = type2;
             const params1 = type1.details.parameters;
@@ -2050,7 +2060,7 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
             }
             return true;
         }
-        case 5 /* OverloadedFunction */: {
+        case 5 /* TypeCategory.OverloadedFunction */: {
             // Make sure the overload counts match.
             const functionType2 = type2;
             if (type1.overloads.length !== functionType2.overloads.length) {
@@ -2065,7 +2075,7 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
             }
             return true;
         }
-        case 8 /* Union */: {
+        case 8 /* TypeCategory.Union */: {
             const unionType2 = type2;
             const subtypes1 = type1.subtypes;
             const subtypes2 = unionType2.subtypes;
@@ -2077,7 +2087,7 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
             const exclusionSet = new Set();
             return (findSubtype(type1, (subtype) => !UnionType.containsType(unionType2, subtype, exclusionSet, recursionCount)) === undefined);
         }
-        case 9 /* TypeVar */: {
+        case 9 /* TypeCategory.TypeVar */: {
             const type2TypeVar = type2;
             if (type1.scopeId !== type2TypeVar.scopeId) {
                 return false;
@@ -2136,7 +2146,7 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
             }
             return true;
         }
-        case 7 /* Module */: {
+        case 7 /* TypeCategory.Module */: {
             const type2Module = type2;
             // Module types are the same if they share the same
             // module symbol table.
@@ -2150,7 +2160,7 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
             }
             return false;
         }
-        case 1 /* Unknown */: {
+        case 1 /* TypeCategory.Unknown */: {
             const type2Unknown = type2;
             return type1.isIncomplete === type2Unknown.isIncomplete;
         }
@@ -2206,12 +2216,12 @@ exports.findSubtype = findSubtype;
 function combineTypes(subtypes, maxSubtypeCount) {
     // Filter out any "Never" and "NoReturn" types.
     let sawNoReturn = false;
-    if (subtypes.some((subtype) => subtype.category === 3 /* Never */))
+    if (subtypes.some((subtype) => subtype.category === 3 /* TypeCategory.Never */))
         subtypes = subtypes.filter((subtype) => {
-            if (subtype.category === 3 /* Never */ && subtype.isNoReturn) {
+            if (subtype.category === 3 /* TypeCategory.Never */ && subtype.isNoReturn) {
                 sawNoReturn = true;
             }
-            return subtype.category !== 3 /* Never */;
+            return subtype.category !== 3 /* TypeCategory.Never */;
         });
     if (subtypes.length === 0) {
         return sawNoReturn ? NeverType.createNoReturn() : NeverType.createNever();