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

package/dist/analyzer/packageTypeVerifier.js

@@ -56,10 +56,10 @@ class PackageTypeVerifier {
         const commonDiagnostics = report.generalDiagnostics;
         try {
             if (!trimmedModuleName) {
-                commonDiagnostics.push(new diagnostic_1.Diagnostic(0 /* Error */, `Module name "${trimmedModuleName}" is invalid`, (0, textRange_1.getEmptyRange)()));
+                commonDiagnostics.push(new diagnostic_1.Diagnostic(0 /* DiagnosticCategory.Error */, `Module name "${trimmedModuleName}" is invalid`, (0, textRange_1.getEmptyRange)()));
             }
             else if (!report.moduleRootDirectory) {
-                commonDiagnostics.push(new diagnostic_1.Diagnostic(0 /* Error */, `Module "${trimmedModuleName}" cannot be resolved`, (0, textRange_1.getEmptyRange)()));
+                commonDiagnostics.push(new diagnostic_1.Diagnostic(0 /* DiagnosticCategory.Error */, `Module "${trimmedModuleName}" cannot be resolved`, (0, textRange_1.getEmptyRange)()));
             }
             else {
                 let pyTypedInfo;
@@ -72,14 +72,14 @@ class PackageTypeVerifier {
                     pyTypedInfo = this._getDeepestPyTypedInfo(report.packageRootDirectory, moduleNameParts);
                 }
                 if (!pyTypedInfo) {
-                    commonDiagnostics.push(new diagnostic_1.Diagnostic(0 /* Error */, 'No py.typed file found', (0, textRange_1.getEmptyRange)()));
+                    commonDiagnostics.push(new diagnostic_1.Diagnostic(0 /* DiagnosticCategory.Error */, 'No py.typed file found', (0, textRange_1.getEmptyRange)()));
                 }
                 else {
                     report.pyTypedPath = pyTypedInfo.pyTypedPath;
                     const publicModules = this._getListOfPublicModules(report.moduleRootDirectory, report.isModuleSingleFile, trimmedModuleName);
                     // If the filter eliminated all modules, report an error.
                     if (publicModules.length === 0) {
-                        commonDiagnostics.push(new diagnostic_1.Diagnostic(0 /* Error */, `Module "${trimmedModuleName}" cannot be resolved`, (0, textRange_1.getEmptyRange)()));
+                        commonDiagnostics.push(new diagnostic_1.Diagnostic(0 /* DiagnosticCategory.Error */, `Module "${trimmedModuleName}" cannot be resolved`, (0, textRange_1.getEmptyRange)()));
                     }
                     // Build a set of all public symbols exported by this package. We'll
                     // use this map to determine which diagnostics to report. We don't want
@@ -98,7 +98,7 @@ class PackageTypeVerifier {
             const message = (e.stack ? e.stack.toString() : undefined) ||
                 (typeof e.message === 'string' ? e.message : undefined) ||
                 JSON.stringify(e);
-            commonDiagnostics.push(new diagnostic_1.Diagnostic(0 /* Error */, `An internal error occurred while verifying types: "${message}"`, (0, textRange_1.getEmptyRange)()));
+            commonDiagnostics.push(new diagnostic_1.Diagnostic(0 /* DiagnosticCategory.Error */, `An internal error occurred while verifying types: "${message}"`, (0, textRange_1.getEmptyRange)()));
         }
         return report;
     }
@@ -154,7 +154,7 @@ class PackageTypeVerifier {
                 };
                 const parseTree = sourceFile.getParseResults().parseTree;
                 const moduleScope = (0, scopeUtils_1.getScopeForNode)(parseTree);
-                this._getPublicSymbolsInSymbolTable(publicSymbols, alternateSymbolNames, module, module.name, moduleScope.symbolTable, 3 /* Module */);
+                this._getPublicSymbolsInSymbolTable(publicSymbols, alternateSymbolNames, module, module.name, moduleScope.symbolTable, 3 /* ScopeType.Module */);
             }
         }
     }
@@ -171,16 +171,16 @@ class PackageTypeVerifier {
                     if (typedDecls.length > 0) {
                         // Is this a class declared within this module or class?
                         // If so, add the symbols declared within it.
-                        const classDecl = typedDecls.find((decl) => decl.type === 6 /* Class */);
+                        const classDecl = typedDecls.find((decl) => decl.type === 6 /* DeclarationType.Class */);
                         if (classDecl) {
                             if ((0, types_1.isInstantiableClass)(symbolType)) {
-                                this._getPublicSymbolsInSymbolTable(publicSymbols, alternateSymbolNames, module, fullName, symbolType.details.fields, 2 /* Class */);
+                                this._getPublicSymbolsInSymbolTable(publicSymbols, alternateSymbolNames, module, fullName, symbolType.details.fields, 2 /* ScopeType.Class */);
                             }
                         }
                     }
                     // Is this the re-export of an import? If so, record the alternate name.
-                    const importDecl = symbol.getDeclarations().find((decl) => decl.type === 8 /* Alias */);
-                    if (importDecl && importDecl.type === 8 /* Alias */) {
+                    const importDecl = symbol.getDeclarations().find((decl) => decl.type === 8 /* DeclarationType.Alias */);
+                    if (importDecl && importDecl.type === 8 /* DeclarationType.Alias */) {
                         const typeName = (0, typeUtils_1.getFullNameOfType)(this._program.getTypeOfSymbol(symbol));
                         if (typeName) {
                             this._addAlternateSymbolName(alternateSymbolNames, typeName, fullName);
@@ -206,10 +206,10 @@ class PackageTypeVerifier {
     _verifyTypesOfModule(moduleName, publicSymbols, report) {
         const importResult = this._resolveImport(moduleName);
         if (!importResult.isImportFound) {
-            report.generalDiagnostics.push(new diagnostic_1.Diagnostic(0 /* Error */, `Could not resolve module "${moduleName}"`, (0, textRange_1.getEmptyRange)()));
+            report.generalDiagnostics.push(new diagnostic_1.Diagnostic(0 /* DiagnosticCategory.Error */, `Could not resolve module "${moduleName}"`, (0, textRange_1.getEmptyRange)()));
         }
         else if (importResult.isStubPackage) {
-            report.generalDiagnostics.push(new diagnostic_1.Diagnostic(0 /* Error */, `No inlined types found for module "${moduleName}" because stub package was present`, (0, textRange_1.getEmptyRange)()));
+            report.generalDiagnostics.push(new diagnostic_1.Diagnostic(0 /* DiagnosticCategory.Error */, `No inlined types found for module "${moduleName}" because stub package was present`, (0, textRange_1.getEmptyRange)()));
         }
         else {
             const modulePath = importResult.resolvedPaths[importResult.resolvedPaths.length - 1];
@@ -224,10 +224,10 @@ class PackageTypeVerifier {
             if (sourceFile) {
                 const parseTree = sourceFile.getParseResults().parseTree;
                 const moduleScope = (0, scopeUtils_1.getScopeForNode)(parseTree);
-                this._getTypeKnownStatusForSymbolTable(report, module.name, moduleScope.symbolTable, 3 /* Module */, publicSymbols);
+                this._getTypeKnownStatusForSymbolTable(report, module.name, moduleScope.symbolTable, 3 /* ScopeType.Module */, publicSymbols);
             }
             else {
-                report.generalDiagnostics.push(new diagnostic_1.Diagnostic(0 /* Error */, `Could not bind file "${modulePath}"`, (0, textRange_1.getEmptyRange)()));
+                report.generalDiagnostics.push(new diagnostic_1.Diagnostic(0 /* DiagnosticCategory.Error */, `Could not bind file "${modulePath}"`, (0, textRange_1.getEmptyRange)()));
             }
         }
     }
@@ -301,9 +301,9 @@ class PackageTypeVerifier {
     }
     _getTypeKnownStatusForSymbolTable(report, scopeName, symbolTable, scopeType, publicSymbols, overrideSymbolCallback) {
         if (this._shouldIgnoreType(report, scopeName)) {
-            return 0 /* Known */;
+            return 0 /* TypeKnownStatus.Known */;
         }
-        let knownStatus = 0 /* Known */;
+        let knownStatus = 0 /* TypeKnownStatus.Known */;
         symbolTable.forEach((symbol, name) => {
             if (!(0, symbolNameUtils_1.isPrivateOrProtectedName)(name) &&
                 !symbol.isExternallyHidden() &&
@@ -344,10 +344,10 @@ class PackageTypeVerifier {
                 const typedDecls = symbol.getTypedDeclarations();
                 const primaryDecl = typedDecls.length > 0 ? typedDecls[typedDecls.length - 1] : undefined;
                 let symbolInfo;
-                if ((primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 6 /* Class */ && (0, types_1.isInstantiableClass)(symbolType)) {
+                if ((primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 6 /* DeclarationType.Class */ && (0, types_1.isInstantiableClass)(symbolType)) {
                     symbolInfo = this._getSymbolForClass(report, symbolType, publicSymbols);
                 }
-                else if ((primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 8 /* Alias */ && (0, types_1.isModule)(symbolType)) {
+                else if ((primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 8 /* DeclarationType.Alias */ && (0, types_1.isModule)(symbolType)) {
                     symbolInfo = this._getSymbolForModule(report, symbolType, publicSymbols);
                 }
                 else {
@@ -360,7 +360,7 @@ class PackageTypeVerifier {
                     // If the only reference to this symbol is a "__slots__" entry, we will
                     // skip it when considering type completeness.
                     if (decls.length === 1 &&
-                        (primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 1 /* Variable */ &&
+                        (primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 1 /* DeclarationType.Variable */ &&
                         primaryDecl.isDefinedBySlots) {
                         return;
                     }
@@ -370,7 +370,7 @@ class PackageTypeVerifier {
                         fullName,
                         filePath: module.path,
                         isExported,
-                        typeKnownStatus: 0 /* Known */,
+                        typeKnownStatus: 0 /* TypeKnownStatus.Known */,
                         referenceCount: 1,
                         diagnostics: [],
                         scopeType,
@@ -396,7 +396,7 @@ class PackageTypeVerifier {
                         }
                     }
                     this._addSymbolError(symbolInfo, `Ambiguous base class override` + extraInfo.getString(), declRange, declPath);
-                    symbolInfo.typeKnownStatus = this._updateKnownStatusIfWorse(symbolInfo.typeKnownStatus, 1 /* Ambiguous */);
+                    symbolInfo.typeKnownStatus = this._updateKnownStatusIfWorse(symbolInfo.typeKnownStatus, 1 /* TypeKnownStatus.Ambiguous */);
                 }
                 knownStatus = this._updateKnownStatusIfWorse(knownStatus, symbolInfo.typeKnownStatus);
             }
@@ -407,16 +407,16 @@ class PackageTypeVerifier {
     // If not, it adds diagnostics to the symbol information and updates the
     // typeKnownStatus field.
     _getSymbolTypeKnownStatus(report, symbolInfo, type, declRange, declFilePath, publicSymbols, skipDocStringCheck = false) {
-        let knownStatus = 0 /* Known */;
+        let knownStatus = 0 /* TypeKnownStatus.Known */;
         if (type.typeAliasInfo && type.typeAliasInfo.typeArguments) {
             type.typeAliasInfo.typeArguments.forEach((typeArg, index) => {
                 if ((0, types_1.isUnknown)(typeArg)) {
                     this._addSymbolError(symbolInfo, `Type argument ${index + 1} for type alias "${type.typeAliasInfo.name}" has unknown type`, declRange, declFilePath);
-                    knownStatus = 3 /* Unknown */;
+                    knownStatus = 3 /* TypeKnownStatus.Unknown */;
                 }
                 else if ((0, typeUtils_1.isPartlyUnknown)(typeArg)) {
                     this._addSymbolError(symbolInfo, `Type argument ${index + 1} for type alias "${type.typeAliasInfo.name}" has partially unknown type`, declRange, declFilePath);
-                    knownStatus = 2 /* PartiallyUnknown */;
+                    knownStatus = 2 /* TypeKnownStatus.PartiallyUnknown */;
                 }
             });
         }
@@ -425,44 +425,44 @@ class PackageTypeVerifier {
             ambiguousDiag.addMessage(`Inferred type is "${this._program.printType(type)}"`);
             this._addSymbolError(symbolInfo, 'Type is missing type annotation and could be inferred differently by type checkers' +
                 ambiguousDiag.getString(), declRange, declFilePath);
-            knownStatus = this._updateKnownStatusIfWorse(knownStatus, 1 /* Ambiguous */);
+            knownStatus = this._updateKnownStatusIfWorse(knownStatus, 1 /* TypeKnownStatus.Ambiguous */);
         }
         switch (type.category) {
-            case 0 /* Unbound */:
-            case 2 /* Any */:
-            case 3 /* Never */:
-            case 9 /* TypeVar */:
+            case 0 /* TypeCategory.Unbound */:
+            case 2 /* TypeCategory.Any */:
+            case 3 /* TypeCategory.Never */:
+            case 9 /* TypeCategory.TypeVar */:
                 break;
-            case 1 /* Unknown */: {
+            case 1 /* TypeCategory.Unknown */: {
                 this._addSymbolError(symbolInfo, `Type unknown for ${PackageTypeVerifier.getSymbolCategoryString(symbolInfo.category)} "${symbolInfo.fullName}"`, declRange, declFilePath);
-                knownStatus = this._updateKnownStatusIfWorse(knownStatus, 3 /* Unknown */);
+                knownStatus = this._updateKnownStatusIfWorse(knownStatus, 3 /* TypeKnownStatus.Unknown */);
                 break;
             }
-            case 8 /* Union */: {
+            case 8 /* TypeCategory.Union */: {
                 (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
                     knownStatus = this._updateKnownStatusIfWorse(knownStatus, this._getSymbolTypeKnownStatus(report, symbolInfo, subtype, declRange, declFilePath, publicSymbols));
                 });
                 break;
             }
-            case 5 /* OverloadedFunction */: {
+            case 5 /* TypeCategory.OverloadedFunction */: {
                 for (const overload of type.overloads) {
                     knownStatus = this._updateKnownStatusIfWorse(knownStatus, this._getSymbolTypeKnownStatus(report, symbolInfo, overload, declRange, declFilePath, publicSymbols));
                 }
                 break;
             }
-            case 4 /* Function */: {
+            case 4 /* TypeCategory.Function */: {
                 if (!this._shouldIgnoreType(report, type.details.fullName)) {
                     knownStatus = this._updateKnownStatusIfWorse(knownStatus, this._getFunctionTypeKnownStatus(report, type, publicSymbols, symbolInfo, declRange, declFilePath, undefined /* diag */, skipDocStringCheck));
                 }
                 break;
             }
-            case 6 /* Class */: {
+            case 6 /* TypeCategory.Class */: {
                 // Properties require special handling.
                 if (types_1.TypeBase.isInstance(type) && types_1.ClassType.isPropertyClass(type)) {
                     const propMethodInfo = [
-                        ['fget', (c) => c.fgetFunction],
-                        ['fset', (c) => c.fsetFunction],
-                        ['fdel', (c) => c.fdelFunction],
+                        ['fget', (c) => { var _a; return (_a = c.fgetInfo) === null || _a === void 0 ? void 0 : _a.methodType; }],
+                        ['fset', (c) => { var _a; return (_a = c.fsetInfo) === null || _a === void 0 ? void 0 : _a.methodType; }],
+                        ['fdel', (c) => { var _a; return (_a = c.fdelInfo) === null || _a === void 0 ? void 0 : _a.methodType; }],
                     ];
                     const propertyClass = type;
                     propMethodInfo.forEach((info) => {
@@ -476,7 +476,7 @@ class PackageTypeVerifier {
                             // work properly when accessed directly from the property object. We need
                             // to remove this flag here so the method is seen as an instance method rather than
                             // static. Otherwise we'll incorrectly report that "self" is not annotated.
-                            accessType = types_1.FunctionType.cloneWithNewFlags(accessType, accessType.details.flags & ~4 /* StaticMethod */);
+                            accessType = types_1.FunctionType.cloneWithNewFlags(accessType, accessType.details.flags & ~4 /* FunctionTypeFlags.StaticMethod */);
                         }
                         // Don't require docstrings for setters or deleters.
                         const skipDocStringCheck = methodName !== 'fget';
@@ -496,22 +496,22 @@ class PackageTypeVerifier {
                     type.typeArguments.forEach((typeArg, index) => {
                         if ((0, types_1.isUnknown)(typeArg)) {
                             this._addSymbolError(symbolInfo, `Type argument ${index + 1} for class "${type.details.name}" has unknown type`, declRange, declFilePath);
-                            knownStatus = this._updateKnownStatusIfWorse(knownStatus, 3 /* Unknown */);
+                            knownStatus = this._updateKnownStatusIfWorse(knownStatus, 3 /* TypeKnownStatus.Unknown */);
                         }
                         else if ((0, typeUtils_1.isPartlyUnknown)(typeArg)) {
                             const diag = new diagnostic_1.DiagnosticAddendum();
                             diag.addMessage(`Type is ${this._program.printType(typeArg)}`);
                             this._addSymbolError(symbolInfo, `Type argument ${index + 1} for class "${type.details.name}" has partially unknown type` + diag.getString(), declRange, declFilePath);
-                            knownStatus = this._updateKnownStatusIfWorse(knownStatus, 2 /* PartiallyUnknown */);
+                            knownStatus = this._updateKnownStatusIfWorse(knownStatus, 2 /* TypeKnownStatus.PartiallyUnknown */);
                         }
                     });
                 }
                 break;
             }
-            case 7 /* Module */: {
+            case 7 /* TypeCategory.Module */: {
                 if (!this._shouldIgnoreType(report, type.moduleName)) {
                     const moduleSymbol = this._getSymbolForModule(report, type, publicSymbols);
-                    if (moduleSymbol.typeKnownStatus !== 0 /* Known */) {
+                    if (moduleSymbol.typeKnownStatus !== 0 /* TypeKnownStatus.Known */) {
                         this._addSymbolError(symbolInfo, `Module "${moduleSymbol.fullName}" is partially unknown`, declRange, declFilePath);
                         knownStatus = this._updateKnownStatusIfWorse(knownStatus, moduleSymbol.typeKnownStatus);
                     }
@@ -524,7 +524,7 @@ class PackageTypeVerifier {
         return knownStatus;
     }
     _getFunctionTypeKnownStatus(report, type, publicSymbols, symbolInfo, declRange, declFilePath, diag, skipDocStringCheck = false) {
-        let knownStatus = 0 /* Known */;
+        let knownStatus = 0 /* TypeKnownStatus.Known */;
         // If the file path wasn't provided, try to get it from the type.
         if (type.details.declaration && !declFilePath) {
             declFilePath = type.details.declaration.path;
@@ -536,7 +536,7 @@ class PackageTypeVerifier {
                     // Allow params (like "self" and "cls") to skip declarations because
                     // we're able to synthesize these.
                     const isSynthesized = index === 0 &&
-                        (symbolInfo === null || symbolInfo === void 0 ? void 0 : symbolInfo.scopeType) === 2 /* Class */ &&
+                        (symbolInfo === null || symbolInfo === void 0 ? void 0 : symbolInfo.scopeType) === 2 /* ScopeType.Class */ &&
                         (types_1.FunctionType.isClassMethod(type) ||
                             types_1.FunctionType.isInstanceMethod(type) ||
                             types_1.FunctionType.isConstructorMethod(type));
@@ -545,7 +545,7 @@ class PackageTypeVerifier {
                             this._addSymbolError(symbolInfo, `Type annotation for parameter "${param.name}" is missing`, declRange !== null && declRange !== void 0 ? declRange : (0, textRange_1.getEmptyRange)(), declFilePath !== null && declFilePath !== void 0 ? declFilePath : '');
                         }
                         diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(`Type annotation for parameter "${param.name}" is missing`);
-                        knownStatus = this._updateKnownStatusIfWorse(knownStatus, 3 /* Unknown */);
+                        knownStatus = this._updateKnownStatusIfWorse(knownStatus, 3 /* TypeKnownStatus.Unknown */);
                     }
                 }
                 else if ((0, types_1.isUnknown)(param.type)) {
@@ -553,12 +553,12 @@ class PackageTypeVerifier {
                         this._addSymbolError(symbolInfo, `Type of parameter "${param.name}" is unknown`, declRange !== null && declRange !== void 0 ? declRange : (0, textRange_1.getEmptyRange)(), declFilePath !== null && declFilePath !== void 0 ? declFilePath : '');
                         diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(`Type of parameter "${param.name}" is unknown`);
                     }
-                    knownStatus = this._updateKnownStatusIfWorse(knownStatus, 3 /* Unknown */);
+                    knownStatus = this._updateKnownStatusIfWorse(knownStatus, 3 /* TypeKnownStatus.Unknown */);
                 }
                 else {
                     const extraInfo = new diagnostic_1.DiagnosticAddendum();
                     const paramKnownStatus = this._getTypeKnownStatus(report, param.type, publicSymbols, extraInfo.createAddendum());
-                    if (paramKnownStatus !== 0 /* Known */) {
+                    if (paramKnownStatus !== 0 /* TypeKnownStatus.Known */) {
                         extraInfo.addMessage(`Parameter type is "${this._program.printType(param.type)}"`);
                         if (symbolInfo) {
                             this._addSymbolError(symbolInfo, `Type of parameter "${param.name}" is partially unknown` + extraInfo.getString(), declRange !== null && declRange !== void 0 ? declRange : (0, textRange_1.getEmptyRange)(), declFilePath !== null && declFilePath !== void 0 ? declFilePath : '');
@@ -578,12 +578,12 @@ class PackageTypeVerifier {
                 if (symbolInfo) {
                     this._addSymbolError(symbolInfo, `Return type is unknown`, declRange !== null && declRange !== void 0 ? declRange : (0, textRange_1.getEmptyRange)(), declFilePath !== null && declFilePath !== void 0 ? declFilePath : '');
                 }
-                knownStatus = this._updateKnownStatusIfWorse(knownStatus, 3 /* Unknown */);
+                knownStatus = this._updateKnownStatusIfWorse(knownStatus, 3 /* TypeKnownStatus.Unknown */);
             }
             else {
                 const extraInfo = new diagnostic_1.DiagnosticAddendum();
                 const returnTypeKnownStatus = this._getTypeKnownStatus(report, type.details.declaredReturnType, publicSymbols, extraInfo.createAddendum());
-                if (returnTypeKnownStatus !== 0 /* Known */) {
+                if (returnTypeKnownStatus !== 0 /* TypeKnownStatus.Known */) {
                     extraInfo.addMessage(`Return type is "${this._program.printType(type.details.declaredReturnType)}"`);
                     if (symbolInfo) {
                         this._addSymbolError(symbolInfo, `Return type is partially unknown` + extraInfo.getString(), declRange !== null && declRange !== void 0 ? declRange : (0, textRange_1.getEmptyRange)(), declFilePath !== null && declFilePath !== void 0 ? declFilePath : '');
@@ -604,7 +604,7 @@ class PackageTypeVerifier {
                     this._addSymbolError(symbolInfo, `Return type annotation is missing`, declRange !== null && declRange !== void 0 ? declRange : (0, textRange_1.getEmptyRange)(), declFilePath !== null && declFilePath !== void 0 ? declFilePath : '');
                 }
                 diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(`Return type annotation is missing`);
-                knownStatus = this._updateKnownStatusIfWorse(knownStatus, 3 /* Unknown */);
+                knownStatus = this._updateKnownStatusIfWorse(knownStatus, 3 /* TypeKnownStatus.Unknown */);
             }
         }
         if (!type.details.docString) {
@@ -651,10 +651,10 @@ class PackageTypeVerifier {
             fullName: type.details.fullName,
             filePath: type.details.filePath,
             isExported: publicSymbols.has(type.details.fullName),
-            typeKnownStatus: 0 /* Known */,
+            typeKnownStatus: 0 /* TypeKnownStatus.Known */,
             referenceCount: 1,
             diagnostics: [],
-            scopeType: 2 /* Class */,
+            scopeType: 2 /* ScopeType.Class */,
         };
         this._addSymbol(report, symbolInfo);
         // Determine whether the class has a proper doc string.
@@ -662,7 +662,7 @@ class PackageTypeVerifier {
             this._addSymbolWarning(symbolInfo, `No docstring found for class "${type.details.fullName}"`, (0, textRange_1.getEmptyRange)(), '');
             report.missingClassDocStringCount++;
         }
-        const symbolTableTypeKnownStatus = this._getTypeKnownStatusForSymbolTable(report, type.details.fullName, type.details.fields, 2 /* Class */, publicSymbols, (name, symbol) => {
+        const symbolTableTypeKnownStatus = this._getTypeKnownStatusForSymbolTable(report, type.details.fullName, type.details.fields, 2 /* ScopeType.Class */, publicSymbols, (name, symbol) => {
             // If the symbol within this class is lacking a type declaration,
             // see if we can find a same-named symbol in a parent class with
             // a type declaration.
@@ -683,12 +683,12 @@ class PackageTypeVerifier {
         if (type.details.effectiveMetaclass) {
             if (!(0, types_1.isInstantiableClass)(type.details.effectiveMetaclass)) {
                 this._addSymbolError(symbolInfo, `Type of metaclass unknown`, (0, textRange_1.getEmptyRange)(), '');
-                symbolInfo.typeKnownStatus = this._updateKnownStatusIfWorse(symbolInfo.typeKnownStatus, 2 /* PartiallyUnknown */);
+                symbolInfo.typeKnownStatus = this._updateKnownStatusIfWorse(symbolInfo.typeKnownStatus, 2 /* TypeKnownStatus.PartiallyUnknown */);
             }
             else {
                 const diag = new diagnostic_1.DiagnosticAddendum();
                 const metaclassKnownStatus = this._getTypeKnownStatus(report, type.details.effectiveMetaclass, publicSymbols, diag);
-                if (metaclassKnownStatus !== 0 /* Known */) {
+                if (metaclassKnownStatus !== 0 /* TypeKnownStatus.Known */) {
                     this._addSymbolError(symbolInfo, `Type of metaclass "${type.details.effectiveMetaclass}" is partially unknown` +
                         diag.getString(), (0, textRange_1.getEmptyRange)(), '');
                     symbolInfo.typeKnownStatus = this._updateKnownStatusIfWorse(symbolInfo.typeKnownStatus, metaclassKnownStatus);
@@ -699,7 +699,7 @@ class PackageTypeVerifier {
         type.details.baseClasses.forEach((baseClass) => {
             if (!(0, types_1.isInstantiableClass)(baseClass)) {
                 this._addSymbolError(symbolInfo, `Type of base class unknown`, (0, textRange_1.getEmptyRange)(), '');
-                symbolInfo.typeKnownStatus = this._updateKnownStatusIfWorse(symbolInfo.typeKnownStatus, 2 /* PartiallyUnknown */);
+                symbolInfo.typeKnownStatus = this._updateKnownStatusIfWorse(symbolInfo.typeKnownStatus, 2 /* TypeKnownStatus.PartiallyUnknown */);
             }
             else {
                 // Handle "tuple" specially. Even though it's a generic class, it
@@ -709,7 +709,7 @@ class PackageTypeVerifier {
                 }
                 const diag = new diagnostic_1.DiagnosticAddendum();
                 const baseClassTypeStatus = this._getTypeKnownStatus(report, baseClass, publicSymbols, diag);
-                if (baseClassTypeStatus !== 0 /* Known */) {
+                if (baseClassTypeStatus !== 0 /* TypeKnownStatus.Known */) {
                     this._addSymbolError(symbolInfo, `Type of base class "${baseClass.details.fullName}" is partially unknown` + diag.getString(), (0, textRange_1.getEmptyRange)(), '');
                     symbolInfo.typeKnownStatus = this._updateKnownStatusIfWorse(symbolInfo.typeKnownStatus, baseClassTypeStatus);
                 }
@@ -730,56 +730,56 @@ class PackageTypeVerifier {
             fullName: type.moduleName,
             filePath: type.filePath,
             isExported: publicSymbols.has(type.moduleName),
-            typeKnownStatus: 0 /* Known */,
+            typeKnownStatus: 0 /* TypeKnownStatus.Known */,
             referenceCount: 1,
             diagnostics: [],
-            scopeType: 3 /* Module */,
+            scopeType: 3 /* ScopeType.Module */,
         };
         this._addSymbol(report, symbolInfo);
-        const symbolTableTypeKnownStatus = this._getTypeKnownStatusForSymbolTable(report, type.moduleName, type.fields, 3 /* Module */, publicSymbols);
+        const symbolTableTypeKnownStatus = this._getTypeKnownStatusForSymbolTable(report, type.moduleName, type.fields, 3 /* ScopeType.Module */, publicSymbols);
         symbolInfo.typeKnownStatus = this._updateKnownStatusIfWorse(symbolInfo.typeKnownStatus, symbolTableTypeKnownStatus);
         return symbolInfo;
     }
     _getTypeKnownStatus(report, type, publicSymbols, diag) {
-        let knownStatus = 0 /* Known */;
+        let knownStatus = 0 /* TypeKnownStatus.Known */;
         if (type.typeAliasInfo && type.typeAliasInfo.typeArguments) {
             type.typeAliasInfo.typeArguments.forEach((typeArg, index) => {
                 if ((0, types_1.isUnknown)(typeArg)) {
                     diag.addMessage(`Type argument ${index + 1} for type alias "${type.typeAliasInfo.name}" has unknown type`);
-                    knownStatus = this._updateKnownStatusIfWorse(knownStatus, 3 /* Unknown */);
+                    knownStatus = this._updateKnownStatusIfWorse(knownStatus, 3 /* TypeKnownStatus.Unknown */);
                 }
                 else if ((0, typeUtils_1.isPartlyUnknown)(typeArg)) {
                     diag.addMessage(`Type argument ${index + 1} for type alias "${type.typeAliasInfo.name}" has partially unknown type`);
-                    knownStatus = this._updateKnownStatusIfWorse(knownStatus, 2 /* PartiallyUnknown */);
+                    knownStatus = this._updateKnownStatusIfWorse(knownStatus, 2 /* TypeKnownStatus.PartiallyUnknown */);
                 }
             });
         }
         if (types_1.TypeBase.isAmbiguous(type)) {
-            knownStatus = this._updateKnownStatusIfWorse(knownStatus, 1 /* Ambiguous */);
+            knownStatus = this._updateKnownStatusIfWorse(knownStatus, 1 /* TypeKnownStatus.Ambiguous */);
         }
         switch (type.category) {
-            case 0 /* Unbound */:
-            case 2 /* Any */:
-            case 3 /* Never */:
-            case 9 /* TypeVar */:
+            case 0 /* TypeCategory.Unbound */:
+            case 2 /* TypeCategory.Any */:
+            case 3 /* TypeCategory.Never */:
+            case 9 /* TypeCategory.TypeVar */:
                 break;
-            case 1 /* Unknown */: {
-                knownStatus = this._updateKnownStatusIfWorse(knownStatus, 3 /* Unknown */);
+            case 1 /* TypeCategory.Unknown */: {
+                knownStatus = this._updateKnownStatusIfWorse(knownStatus, 3 /* TypeKnownStatus.Unknown */);
                 break;
             }
-            case 8 /* Union */: {
+            case 8 /* TypeCategory.Union */: {
                 (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
                     knownStatus = this._updateKnownStatusIfWorse(knownStatus, this._getTypeKnownStatus(report, subtype, publicSymbols, diag.createAddendum()));
                 });
                 break;
             }
-            case 5 /* OverloadedFunction */: {
+            case 5 /* TypeCategory.OverloadedFunction */: {
                 for (const overload of type.overloads) {
                     knownStatus = this._updateKnownStatusIfWorse(knownStatus, this._getTypeKnownStatus(report, overload, publicSymbols, diag.createAddendum()));
                 }
                 break;
             }
-            case 4 /* Function */: {
+            case 4 /* TypeCategory.Function */: {
                 if (!this._shouldIgnoreType(report, type.details.fullName)) {
                     knownStatus = this._updateKnownStatusIfWorse(knownStatus, this._getFunctionTypeKnownStatus(report, type, publicSymbols, 
                     /* symbolInfo */ undefined, 
@@ -788,7 +788,7 @@ class PackageTypeVerifier {
                 }
                 break;
             }
-            case 6 /* Class */: {
+            case 6 /* TypeCategory.Class */: {
                 if (!this._shouldIgnoreType(report, type.details.fullName)) {
                     // Don't bother type-checking built-in types.
                     if (!types_1.ClassType.isBuiltIn(type)) {
@@ -801,17 +801,17 @@ class PackageTypeVerifier {
                     type.typeArguments.forEach((typeArg, index) => {
                         if ((0, types_1.isUnknown)(typeArg)) {
                             diag.addMessage(`Type argument ${index + 1} for class "${type.details.name}" has unknown type`);
-                            knownStatus = this._updateKnownStatusIfWorse(knownStatus, 3 /* Unknown */);
+                            knownStatus = this._updateKnownStatusIfWorse(knownStatus, 3 /* TypeKnownStatus.Unknown */);
                         }
                         else if ((0, typeUtils_1.isPartlyUnknown)(typeArg)) {
                             diag.addMessage(`Type argument ${index + 1} for class "${type.details.name}" has partially unknown type`);
-                            knownStatus = this._updateKnownStatusIfWorse(knownStatus, 2 /* PartiallyUnknown */);
+                            knownStatus = this._updateKnownStatusIfWorse(knownStatus, 2 /* TypeKnownStatus.PartiallyUnknown */);
                         }
                     });
                 }
                 break;
             }
-            case 7 /* Module */: {
+            case 7 /* TypeCategory.Module */: {
                 if (!this._shouldIgnoreType(report, type.moduleName)) {
                     const moduleSymbol = this._getSymbolForModule(report, type, publicSymbols);
                     knownStatus = this._updateKnownStatusIfWorse(knownStatus, moduleSymbol.typeKnownStatus);
@@ -826,38 +826,38 @@ class PackageTypeVerifier {
             return packageTypeReport_1.SymbolCategory.TypeAlias;
         }
         switch (type.category) {
-            case 4 /* Function */:
-            case 5 /* OverloadedFunction */: {
+            case 4 /* TypeCategory.Function */:
+            case 5 /* TypeCategory.OverloadedFunction */: {
                 const funcDecl = symbol
                     .getDeclarations()
-                    .find((decl) => decl.type === 5 /* Function */);
+                    .find((decl) => decl.type === 5 /* DeclarationType.Function */);
                 if (funcDecl && funcDecl.isMethod) {
                     return packageTypeReport_1.SymbolCategory.Method;
                 }
                 return packageTypeReport_1.SymbolCategory.Function;
             }
-            case 6 /* Class */: {
+            case 6 /* TypeCategory.Class */: {
                 if (types_1.TypeBase.isInstantiable(type)) {
                     return packageTypeReport_1.SymbolCategory.Class;
                 }
                 const varDecl = symbol
                     .getDeclarations()
-                    .find((decl) => decl.type === 1 /* Variable */);
+                    .find((decl) => decl.type === 1 /* DeclarationType.Variable */);
                 if (varDecl && (varDecl.isConstant || varDecl.isFinal)) {
                     return packageTypeReport_1.SymbolCategory.Constant;
                 }
                 return packageTypeReport_1.SymbolCategory.Variable;
             }
-            case 7 /* Module */: {
+            case 7 /* TypeCategory.Module */: {
                 return packageTypeReport_1.SymbolCategory.Module;
             }
-            case 9 /* TypeVar */: {
+            case 9 /* TypeCategory.TypeVar */: {
                 return packageTypeReport_1.SymbolCategory.TypeVar;
             }
             default: {
                 const varDecl = symbol
                     .getDeclarations()
-                    .find((decl) => decl.type === 1 /* Variable */);
+                    .find((decl) => decl.type === 1 /* DeclarationType.Variable */);
                 if (varDecl) {
                     if (varDecl.isConstant || varDecl.isFinal) {
                         return packageTypeReport_1.SymbolCategory.Constant;
@@ -890,7 +890,7 @@ class PackageTypeVerifier {
         return undefined;
     }
     _isSymbolTypeImplied(scopeType, name) {
-        if (scopeType === 2 /* Class */) {
+        if (scopeType === 2 /* ScopeType.Class */) {
             const knownClassSymbols = [
                 '__class__',
                 '__dict__',
@@ -903,7 +903,7 @@ class PackageTypeVerifier {
             ];
             return knownClassSymbols.some((sym) => sym === name);
         }
-        else if (scopeType === 3 /* Module */) {
+        else if (scopeType === 3 /* ScopeType.Module */) {
             const knownModuleSymbols = [
                 '__all__',
                 '__author__',
@@ -924,13 +924,13 @@ class PackageTypeVerifier {
     }
     _addSymbolError(symbolInfo, message, declRange, declFilePath) {
         symbolInfo.diagnostics.push({
-            diagnostic: new diagnostic_1.Diagnostic(0 /* Error */, message, declRange),
+            diagnostic: new diagnostic_1.Diagnostic(0 /* DiagnosticCategory.Error */, message, declRange),
             filePath: declFilePath,
         });
     }
     _addSymbolWarning(symbolInfo, message, declRange, declFilePath) {
         symbolInfo.diagnostics.push({
-            diagnostic: new diagnostic_1.Diagnostic(1 /* Warning */, message, declRange),
+            diagnostic: new diagnostic_1.Diagnostic(1 /* DiagnosticCategory.Warning */, message, declRange),
             filePath: declFilePath,
         });
     }