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

package/dist/analyzer/typeWalker.js

@@ -37,34 +37,34 @@ class TypeWalker {
             this.visitTypeAlias(type);
         }
         switch (type.category) {
-            case 0 /* Unbound */:
+            case 0 /* TypeCategory.Unbound */:
                 this.visitUnbound(type);
                 break;
-            case 2 /* Any */:
+            case 2 /* TypeCategory.Any */:
                 this.visitAny(type);
                 break;
-            case 1 /* Unknown */:
+            case 1 /* TypeCategory.Unknown */:
                 this.visitUnknown(type);
                 break;
-            case 3 /* Never */:
+            case 3 /* TypeCategory.Never */:
                 this.visitNever(type);
                 break;
-            case 4 /* Function */:
+            case 4 /* TypeCategory.Function */:
                 this.visitFunction(type);
                 break;
-            case 5 /* OverloadedFunction */:
+            case 5 /* TypeCategory.OverloadedFunction */:
                 this.visitOverloadedFunction(type);
                 break;
-            case 6 /* Class */:
+            case 6 /* TypeCategory.Class */:
                 this.visitClass(type);
                 break;
-            case 7 /* Module */:
+            case 7 /* TypeCategory.Module */:
                 this.visitModule(type);
                 break;
-            case 8 /* Union */:
+            case 8 /* TypeCategory.Union */:
                 this.visitUnion(type);
                 break;
-            case 9 /* TypeVar */:
+            case 9 /* TypeCategory.TypeVar */:
                 this.visitTypeVar(type);
                 break;
             default:

package/dist/analyzer/typedDicts.js

@@ -10,7 +10,11 @@
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -56,30 +60,30 @@ function createTypedDictType(evaluator, errorNode, typedDictClass, argList) {
     }
     else {
         const nameArg = argList[0];
-        if (nameArg.argumentCategory !== 0 /* Simple */ ||
+        if (nameArg.argumentCategory !== 0 /* ArgumentCategory.Simple */ ||
             !nameArg.valueExpression ||
-            nameArg.valueExpression.nodeType !== 48 /* StringList */) {
+            nameArg.valueExpression.nodeType !== 48 /* ParseNodeType.StringList */) {
             evaluator.addError(localize_1.Localizer.Diagnostic.typedDictFirstArg(), argList[0].valueExpression || errorNode);
         }
         else {
             className = nameArg.valueExpression.strings.map((s) => s.value).join('');
         }
     }
-    const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, 128 /* TypedDictClass */, ParseTreeUtils.getTypeSourceId(errorNode), 
+    const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, 128 /* ClassTypeFlags.TypedDictClass */, ParseTreeUtils.getTypeSourceId(errorNode), 
     /* declaredMetaclass */ undefined, typedDictClass.details.effectiveMetaclass);
     classType.details.baseClasses.push(typedDictClass);
     (0, typeUtils_1.computeMroLinearization)(classType);
     const classFields = classType.details.fields;
-    classFields.set('__class__', symbol_1.Symbol.createWithType(4 /* ClassMember */ | 64 /* IgnoredForProtocolMatch */, classType));
+    classFields.set('__class__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */ | 64 /* SymbolFlags.IgnoredForProtocolMatch */, classType));
     let usingDictSyntax = false;
     if (argList.length < 2) {
         evaluator.addError(localize_1.Localizer.Diagnostic.typedDictSecondArgDict(), errorNode);
     }
     else {
         const entriesArg = argList[1];
-        if (entriesArg.argumentCategory === 0 /* Simple */ &&
+        if (entriesArg.argumentCategory === 0 /* ArgumentCategory.Simple */ &&
             entriesArg.valueExpression &&
-            entriesArg.valueExpression.nodeType === 15 /* Dictionary */) {
+            entriesArg.valueExpression.nodeType === 15 /* ParseNodeType.Dictionary */) {
             usingDictSyntax = true;
             getTypedDictFieldsFromDictSyntax(evaluator, entriesArg.valueExpression, classFields, /* isInline */ false);
         }
@@ -96,10 +100,10 @@ function createTypedDictType(evaluator, errorNode, typedDictClass, argList) {
                 }
                 // Record names in a map to detect duplicates.
                 entrySet.add(entry.name.value);
-                const newSymbol = new symbol_1.Symbol(8 /* InstanceMember */);
+                const newSymbol = new symbol_1.Symbol(8 /* SymbolFlags.InstanceMember */);
                 const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
                 const declaration = {
-                    type: 1 /* Variable */,
+                    type: 1 /* DeclarationType.Variable */,
                     node: entry.name,
                     path: fileInfo.filePath,
                     typeAnnotationNode: entry.valueExpression,
@@ -120,13 +124,13 @@ function createTypedDictType(evaluator, errorNode, typedDictClass, argList) {
         for (const arg of argList.slice(2)) {
             if (((_a = arg.name) === null || _a === void 0 ? void 0 : _a.value) === 'total') {
                 if (!arg.valueExpression ||
-                    arg.valueExpression.nodeType !== 11 /* Constant */ ||
-                    !(arg.valueExpression.constType === 15 /* False */ ||
-                        arg.valueExpression.constType === 33 /* True */)) {
+                    arg.valueExpression.nodeType !== 11 /* ParseNodeType.Constant */ ||
+                    !(arg.valueExpression.constType === 15 /* KeywordType.False */ ||
+                        arg.valueExpression.constType === 33 /* KeywordType.True */)) {
                     evaluator.addError(localize_1.Localizer.Diagnostic.typedDictBoolParam().format({ name: arg.name.value }), arg.valueExpression || errorNode);
                 }
-                else if (arg.name.value === 'total' && arg.valueExpression.constType === 15 /* False */) {
-                    classType.details.flags |= 256 /* CanOmitDictValues */;
+                else if (arg.name.value === 'total' && arg.valueExpression.constType === 15 /* KeywordType.False */) {
+                    classType.details.flags |= 256 /* ClassTypeFlags.CanOmitDictValues */;
                 }
             }
             else {
@@ -142,7 +146,7 @@ exports.createTypedDictType = createTypedDictType;
 function createTypedDictTypeInlined(evaluator, dictNode, typedDictClass) {
     const fileInfo = AnalyzerNodeInfo.getFileInfo(dictNode);
     const className = '<TypedDict>';
-    const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(dictNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, 128 /* TypedDictClass */, ParseTreeUtils.getTypeSourceId(dictNode), 
+    const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(dictNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, 128 /* ClassTypeFlags.TypedDictClass */, ParseTreeUtils.getTypeSourceId(dictNode), 
     /* declaredMetaclass */ undefined, typedDictClass.details.effectiveMetaclass);
     classType.details.baseClasses.push(typedDictClass);
     (0, typeUtils_1.computeMroLinearization)(classType);
@@ -154,9 +158,9 @@ exports.createTypedDictTypeInlined = createTypedDictTypeInlined;
 function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFinal) {
     (0, debug_1.assert)(types_1.ClassType.isTypedDictClass(classType));
     // Synthesize a __new__ method.
-    const newType = types_1.FunctionType.createSynthesizedInstance('__new__', 1 /* ConstructorMethod */);
+    const newType = types_1.FunctionType.createSynthesizedInstance('__new__', 1 /* FunctionTypeFlags.ConstructorMethod */);
     types_1.FunctionType.addParameter(newType, {
-        category: 0 /* Simple */,
+        category: 0 /* ParameterCategory.Simple */,
         name: 'cls',
         type: classType,
         hasDeclaredType: true,
@@ -164,9 +168,9 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFina
     types_1.FunctionType.addDefaultParameters(newType);
     newType.details.declaredReturnType = types_1.ClassType.cloneAsInstance(classType);
     // Synthesize an __init__ method with two overrides.
-    const initOverride1 = types_1.FunctionType.createSynthesizedInstance('__init__', 256 /* Overloaded */);
+    const initOverride1 = types_1.FunctionType.createSynthesizedInstance('__init__', 256 /* FunctionTypeFlags.Overloaded */);
     types_1.FunctionType.addParameter(initOverride1, {
-        category: 0 /* Simple */,
+        category: 0 /* ParameterCategory.Simple */,
         name: 'self',
         type: types_1.ClassType.cloneAsInstance(classType),
         hasDeclaredType: true,
@@ -174,25 +178,25 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFina
     initOverride1.details.declaredReturnType = evaluator.getNoneType();
     // The first parameter must be positional-only.
     types_1.FunctionType.addParameter(initOverride1, {
-        category: 0 /* Simple */,
+        category: 0 /* ParameterCategory.Simple */,
         name: '__map',
         type: types_1.ClassType.cloneAsInstance(classType),
         hasDeclaredType: true,
     });
     types_1.FunctionType.addParameter(initOverride1, {
-        category: 0 /* Simple */,
+        category: 0 /* ParameterCategory.Simple */,
         name: '',
         type: types_1.UnknownType.create(),
     });
     // All subsequent parameters must be named, so insert an empty "*".
     types_1.FunctionType.addParameter(initOverride1, {
-        category: 1 /* ArgsList */,
+        category: 1 /* ParameterCategory.ArgsList */,
         type: types_1.AnyType.create(),
         hasDeclaredType: true,
     });
-    const initOverride2 = types_1.FunctionType.createSynthesizedInstance('__init__', 256 /* Overloaded */);
+    const initOverride2 = types_1.FunctionType.createSynthesizedInstance('__init__', 256 /* FunctionTypeFlags.Overloaded */);
     types_1.FunctionType.addParameter(initOverride2, {
-        category: 0 /* Simple */,
+        category: 0 /* ParameterCategory.Simple */,
         name: 'self',
         type: types_1.ClassType.cloneAsInstance(classType),
         hasDeclaredType: true,
@@ -200,7 +204,7 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFina
     initOverride2.details.declaredReturnType = evaluator.getNoneType();
     // All parameters must be named, so insert an empty "*".
     types_1.FunctionType.addParameter(initOverride2, {
-        category: 1 /* ArgsList */,
+        category: 1 /* ParameterCategory.ArgsList */,
         type: types_1.AnyType.create(),
         hasDeclaredType: true,
     });
@@ -209,14 +213,14 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFina
     let allEntriesAreReadOnly = true;
     entries.forEach((entry, name) => {
         types_1.FunctionType.addParameter(initOverride1, {
-            category: 0 /* Simple */,
+            category: 0 /* ParameterCategory.Simple */,
             name,
             hasDefault: true,
             type: entry.valueType,
             hasDeclaredType: true,
         });
         types_1.FunctionType.addParameter(initOverride2, {
-            category: 0 /* Simple */,
+            category: 0 /* ParameterCategory.Simple */,
             name,
             hasDefault: !entry.isRequired,
             type: entry.valueType,
@@ -231,28 +235,28 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFina
     });
     const symbolTable = classType.details.fields;
     const initType = types_1.OverloadedFunctionType.create([initOverride1, initOverride2]);
-    symbolTable.set('__init__', symbol_1.Symbol.createWithType(4 /* ClassMember */, initType));
-    symbolTable.set('__new__', symbol_1.Symbol.createWithType(4 /* ClassMember */, newType));
+    symbolTable.set('__init__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, initType));
+    symbolTable.set('__new__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, newType));
     const strClass = evaluator.getBuiltInType(node, 'str');
     // Synthesize a "get", pop, and setdefault method for each named entry.
     if ((0, types_1.isInstantiableClass)(strClass)) {
         const selfParam = {
-            category: 0 /* Simple */,
+            category: 0 /* ParameterCategory.Simple */,
             name: 'self',
             type: types_1.ClassType.cloneAsInstance(classType),
             hasDeclaredType: true,
         };
         function createDefaultTypeVar(func) {
             let defaultTypeVar = types_1.TypeVarType.createInstance(`__TDefault`);
-            defaultTypeVar = types_1.TypeVarType.cloneForScopeId(defaultTypeVar, func.details.typeVarScopeId, classType.details.name, 1 /* Function */);
+            defaultTypeVar = types_1.TypeVarType.cloneForScopeId(defaultTypeVar, func.details.typeVarScopeId, classType.details.name, 1 /* TypeVarScopeType.Function */);
             return defaultTypeVar;
         }
         function createGetMethod(keyType, valueType, includeDefault, isEntryRequired = false, defaultTypeMatchesField = false) {
-            const getOverload = types_1.FunctionType.createSynthesizedInstance('get', 256 /* Overloaded */);
+            const getOverload = types_1.FunctionType.createSynthesizedInstance('get', 256 /* FunctionTypeFlags.Overloaded */);
             types_1.FunctionType.addParameter(getOverload, selfParam);
             getOverload.details.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
             types_1.FunctionType.addParameter(getOverload, {
-                category: 0 /* Simple */,
+                category: 0 /* ParameterCategory.Simple */,
                 name: 'k',
                 type: keyType,
                 hasDeclaredType: true,
@@ -277,7 +281,7 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFina
                     returnType = defaultParamType;
                 }
                 types_1.FunctionType.addParameter(getOverload, {
-                    category: 0 /* Simple */,
+                    category: 0 /* ParameterCategory.Simple */,
                     name: 'default',
                     type: defaultParamType,
                     hasDeclaredType: true,
@@ -293,16 +297,16 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFina
         }
         function createPopMethods(keyType, valueType, isEntryRequired) {
             const keyParam = {
-                category: 0 /* Simple */,
+                category: 0 /* ParameterCategory.Simple */,
                 name: 'k',
                 type: keyType,
                 hasDeclaredType: true,
             };
-            const popOverload1 = types_1.FunctionType.createSynthesizedInstance('pop', 256 /* Overloaded */);
+            const popOverload1 = types_1.FunctionType.createSynthesizedInstance('pop', 256 /* FunctionTypeFlags.Overloaded */);
             types_1.FunctionType.addParameter(popOverload1, selfParam);
             types_1.FunctionType.addParameter(popOverload1, keyParam);
             popOverload1.details.declaredReturnType = valueType;
-            const popOverload2 = types_1.FunctionType.createSynthesizedInstance('pop', 256 /* Overloaded */);
+            const popOverload2 = types_1.FunctionType.createSynthesizedInstance('pop', 256 /* FunctionTypeFlags.Overloaded */);
             types_1.FunctionType.addParameter(popOverload2, selfParam);
             types_1.FunctionType.addParameter(popOverload2, keyParam);
             popOverload2.details.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
@@ -320,7 +324,7 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFina
                 returnType = defaultParamType;
             }
             types_1.FunctionType.addParameter(popOverload2, {
-                category: 0 /* Simple */,
+                category: 0 /* ParameterCategory.Simple */,
                 name: 'default',
                 hasDeclaredType: true,
                 type: defaultParamType,
@@ -330,16 +334,16 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFina
             return [popOverload1, popOverload2];
         }
         function createSetDefaultMethod(keyType, valueType) {
-            const setDefaultOverload = types_1.FunctionType.createSynthesizedInstance('setdefault', 256 /* Overloaded */);
+            const setDefaultOverload = types_1.FunctionType.createSynthesizedInstance('setdefault', 256 /* FunctionTypeFlags.Overloaded */);
             types_1.FunctionType.addParameter(setDefaultOverload, selfParam);
             types_1.FunctionType.addParameter(setDefaultOverload, {
-                category: 0 /* Simple */,
+                category: 0 /* ParameterCategory.Simple */,
                 name: 'k',
                 hasDeclaredType: true,
                 type: keyType,
             });
             types_1.FunctionType.addParameter(setDefaultOverload, {
-                category: 0 /* Simple */,
+                category: 0 /* ParameterCategory.Simple */,
                 name: 'default',
                 hasDeclaredType: true,
                 type: valueType,
@@ -348,10 +352,10 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFina
             return setDefaultOverload;
         }
         function createDelItemMethod(keyType) {
-            const delItemOverload = types_1.FunctionType.createSynthesizedInstance('delitem', 256 /* Overloaded */);
+            const delItemOverload = types_1.FunctionType.createSynthesizedInstance('delitem', 256 /* FunctionTypeFlags.Overloaded */);
             types_1.FunctionType.addParameter(delItemOverload, selfParam);
             types_1.FunctionType.addParameter(delItemOverload, {
-                category: 0 /* Simple */,
+                category: 0 /* ParameterCategory.Simple */,
                 name: 'k',
                 hasDeclaredType: true,
                 type: keyType,
@@ -361,17 +365,17 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFina
         }
         function createUpdateMethod() {
             // Overload 1: update(__m: Partial[<writable fields>], /)
-            const updateMethod1 = types_1.FunctionType.createSynthesizedInstance('update', 256 /* Overloaded */);
+            const updateMethod1 = types_1.FunctionType.createSynthesizedInstance('update', 256 /* FunctionTypeFlags.Overloaded */);
             types_1.FunctionType.addParameter(updateMethod1, selfParam);
             // Overload 2: update(__m: Iterable[tuple[<name>, <type>]], /)
-            const updateMethod2 = types_1.FunctionType.createSynthesizedInstance('update', 256 /* Overloaded */);
+            const updateMethod2 = types_1.FunctionType.createSynthesizedInstance('update', 256 /* FunctionTypeFlags.Overloaded */);
             types_1.FunctionType.addParameter(updateMethod2, selfParam);
             // Overload 3: update(*, <name>: <type>, ...)
-            const updateMethod3 = types_1.FunctionType.createSynthesizedInstance('update', 256 /* Overloaded */);
+            const updateMethod3 = types_1.FunctionType.createSynthesizedInstance('update', 256 /* FunctionTypeFlags.Overloaded */);
             types_1.FunctionType.addParameter(updateMethod3, selfParam);
             // If all entries are read-only, don't allow updates.
             types_1.FunctionType.addParameter(updateMethod1, {
-                category: 0 /* Simple */,
+                category: 0 /* ParameterCategory.Simple */,
                 name: '__m',
                 hasDeclaredType: true,
                 type: allEntriesAreReadOnly
@@ -379,12 +383,12 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFina
                     : types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForPartialTypedDict(classType)),
             });
             types_1.FunctionType.addParameter(updateMethod1, {
-                category: 0 /* Simple */,
+                category: 0 /* ParameterCategory.Simple */,
                 name: '',
                 type: types_1.AnyType.create(),
             });
             types_1.FunctionType.addParameter(updateMethod3, {
-                category: 1 /* ArgsList */,
+                category: 1 /* ParameterCategory.ArgsList */,
                 name: '',
                 hasDeclaredType: false,
                 type: types_1.UnknownType.create(),
@@ -409,7 +413,7 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFina
                     }
                     // For writable entries, add a keyword argument.
                     types_1.FunctionType.addParameter(updateMethod3, {
-                        category: 0 /* Simple */,
+                        category: 0 /* ParameterCategory.Simple */,
                         name,
                         hasDeclaredType: true,
                         hasDefault: true,
@@ -422,7 +426,7 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFina
             if (iterableClass && (0, types_1.isInstantiableClass)(iterableClass)) {
                 const iterableType = types_1.ClassType.cloneAsInstance(iterableClass);
                 types_1.FunctionType.addParameter(updateMethod2, {
-                    category: 0 /* Simple */,
+                    category: 0 /* ParameterCategory.Simple */,
                     name: '__m',
                     hasDeclaredType: true,
                     type: types_1.ClassType.cloneForSpecialization(iterableType, [(0, types_1.combineTypes)(tuplesToCombine)], 
@@ -430,7 +434,7 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFina
                 });
             }
             types_1.FunctionType.addParameter(updateMethod2, {
-                category: 0 /* Simple */,
+                category: 0 /* ParameterCategory.Simple */,
                 name: '',
                 type: types_1.AnyType.create(),
             });
@@ -474,24 +478,24 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFina
         const strType = types_1.ClassType.cloneAsInstance(strClass);
         getOverloads.push(createGetMethod(strType, types_1.AnyType.create(), /* includeDefault */ false));
         getOverloads.push(createGetMethod(strType, types_1.AnyType.create(), /* includeDefault */ true));
-        symbolTable.set('get', symbol_1.Symbol.createWithType(4 /* ClassMember */, types_1.OverloadedFunctionType.create(getOverloads)));
+        symbolTable.set('get', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, types_1.OverloadedFunctionType.create(getOverloads)));
         if (popOverloads.length > 0) {
-            symbolTable.set('pop', symbol_1.Symbol.createWithType(4 /* ClassMember */, types_1.OverloadedFunctionType.create(popOverloads)));
+            symbolTable.set('pop', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, types_1.OverloadedFunctionType.create(popOverloads)));
         }
         if (setDefaultOverloads.length > 0) {
-            symbolTable.set('setdefault', symbol_1.Symbol.createWithType(4 /* ClassMember */, types_1.OverloadedFunctionType.create(setDefaultOverloads)));
+            symbolTable.set('setdefault', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, types_1.OverloadedFunctionType.create(setDefaultOverloads)));
         }
         if (!allEntriesAreReadOnly) {
-            symbolTable.set('__delitem__', symbol_1.Symbol.createWithType(4 /* ClassMember */, createDelItemMethod(strType)));
+            symbolTable.set('__delitem__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, createDelItemMethod(strType)));
         }
-        symbolTable.set('update', symbol_1.Symbol.createWithType(4 /* ClassMember */, createUpdateMethod()));
+        symbolTable.set('update', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, createUpdateMethod()));
         // If the TypedDict is final and all of its entries are NotRequired,
         // add a "clear" and "popitem" method.
         if (isClassFinal && allEntriesAreNotRequired && !allEntriesAreReadOnly) {
             const clearMethod = types_1.FunctionType.createSynthesizedInstance('clear');
             types_1.FunctionType.addParameter(clearMethod, selfParam);
             clearMethod.details.declaredReturnType = evaluator.getNoneType();
-            symbolTable.set('clear', symbol_1.Symbol.createWithType(4 /* ClassMember */, clearMethod));
+            symbolTable.set('clear', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, clearMethod));
             const popItemMethod = types_1.FunctionType.createSynthesizedInstance('popitem');
             types_1.FunctionType.addParameter(popItemMethod, selfParam);
             let tupleType = evaluator.getTupleClassType();
@@ -506,7 +510,7 @@ function synthesizeTypedDictClassMethods(evaluator, node, classType, isClassFina
                 tupleType = types_1.UnknownType.create();
             }
             popItemMethod.details.declaredReturnType = tupleType;
-            symbolTable.set('popitem', symbol_1.Symbol.createWithType(4 /* ClassMember */, popItemMethod));
+            symbolTable.set('popitem', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, popItemMethod));
         }
     }
 }
@@ -553,11 +557,11 @@ function getTypedDictFieldsFromDictSyntax(evaluator, entryDict, classFields, isI
     const entrySet = new Set();
     const fileInfo = AnalyzerNodeInfo.getFileInfo(entryDict);
     entryDict.entries.forEach((entry) => {
-        if (entry.nodeType !== 17 /* DictionaryKeyEntry */) {
+        if (entry.nodeType !== 17 /* ParseNodeType.DictionaryKeyEntry */) {
             evaluator.addError(localize_1.Localizer.Diagnostic.typedDictSecondArgDictEntry(), entry);
             return;
         }
-        if (entry.keyExpression.nodeType !== 48 /* StringList */) {
+        if (entry.keyExpression.nodeType !== 48 /* ParseNodeType.StringList */) {
             evaluator.addError(localize_1.Localizer.Diagnostic.typedDictEntryName(), entry.keyExpression);
             return;
         }
@@ -572,9 +576,9 @@ function getTypedDictFieldsFromDictSyntax(evaluator, entryDict, classFields, isI
         }
         // Record names in a set to detect duplicates.
         entrySet.add(entryName);
-        const newSymbol = new symbol_1.Symbol(8 /* InstanceMember */);
+        const newSymbol = new symbol_1.Symbol(8 /* SymbolFlags.InstanceMember */);
         const declaration = {
-            type: 1 /* Variable */,
+            type: 1 /* DeclarationType.Variable */,
             node: entry.keyExpression,
             path: fileInfo.filePath,
             typeAnnotationNode: entry.valueExpression,
@@ -609,7 +613,7 @@ function getTypedDictMembersForClassRecursive(evaluator, classType, keyMap, recu
         if (!symbol.isIgnoredForProtocolMatch()) {
             // Only variables (not functions, classes, etc.) are considered.
             const lastDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
-            if (lastDecl && lastDecl.type === 1 /* Variable */) {
+            if (lastDecl && lastDecl.type === 1 /* DeclarationType.Variable */) {
                 let valueType = evaluator.getEffectiveTypeOfSymbol(symbol);
                 valueType = (0, typeUtils_1.applySolvedTypeVars)(valueType, typeVarContext);
                 let isRequired = !types_1.ClassType.isCanOmitDictValues(classType);
@@ -715,7 +719,7 @@ function assignTypedDictToTypedDict(evaluator, destType, srcType, diag, typeVarC
             let adjustedFlags = flags;
             // If the dest field is not read-only, we need to enforce invariance.
             if (!destEntry.isReadOnly) {
-                adjustedFlags |= 1 /* EnforceInvariance */;
+                adjustedFlags |= 1 /* AssignTypeFlags.EnforceInvariance */;
             }
             if (!evaluator.assignType(destEntry.valueType, srcEntry.valueType, subDiag === null || subDiag === void 0 ? void 0 : subDiag.createAddendum(), typeVarContext, 
             /* srcTypeVarContext */ undefined, adjustedFlags, recursionCount)) {
@@ -775,7 +779,7 @@ function assignToTypedDict(evaluator, classType, keyTypes, valueTypes, diagAdden
                 // Can we assign the value to the declared type?
                 const subDiag = diagAddendum === null || diagAddendum === void 0 ? void 0 : diagAddendum.createAddendum();
                 if (!evaluator.assignType(symbolEntry.valueType, valueTypes[index].type, subDiag === null || subDiag === void 0 ? void 0 : subDiag.createAddendum(), typeVarContext, 
-                /* srcTypeVarContext */ undefined, 128 /* RetainLiteralsForTypeVar */)) {
+                /* srcTypeVarContext */ undefined, 128 /* AssignTypeFlags.RetainLiteralsForTypeVar */)) {
                     if (subDiag) {
                         subDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.typedDictFieldTypeMismatch().format({
                             name: keyType.literalValue,
@@ -829,7 +833,7 @@ function getTypeOfIndexedTypedDict(evaluator, node, baseType, usage) {
         return { type: types_1.UnknownType.create() };
     }
     // Look for subscript types that are not supported by TypedDict.
-    if (node.trailingComma || node.items[0].name || node.items[0].argumentCategory !== 0 /* Simple */) {
+    if (node.trailingComma || node.items[0].name || node.items[0].argumentCategory !== 0 /* ArgumentCategory.Simple */) {
         return undefined;
     }
     const entries = getTypedDictMembersForClass(evaluator, baseType, /* allowNarrowed */ usage.method === 'get');
@@ -949,7 +953,7 @@ function narrowForKeyAssignment(classType, key) {
 exports.narrowForKeyAssignment = narrowForKeyAssignment;
 function isRequiredTypedDictVariable(evaluator, symbol) {
     return symbol.getDeclarations().some((decl) => {
-        if (decl.type !== 1 /* Variable */ || !decl.typeAnnotationNode) {
+        if (decl.type !== 1 /* DeclarationType.Variable */ || !decl.typeAnnotationNode) {
             return false;
         }
         const annotatedType = evaluator.getTypeOfExpressionExpectingType(decl.typeAnnotationNode, {
@@ -961,7 +965,7 @@ function isRequiredTypedDictVariable(evaluator, symbol) {
 }
 function isNotRequiredTypedDictVariable(evaluator, symbol) {
     return symbol.getDeclarations().some((decl) => {
-        if (decl.type !== 1 /* Variable */ || !decl.typeAnnotationNode) {
+        if (decl.type !== 1 /* DeclarationType.Variable */ || !decl.typeAnnotationNode) {
             return false;
         }
         const annotatedType = evaluator.getTypeOfExpressionExpectingType(decl.typeAnnotationNode, {
@@ -973,7 +977,7 @@ function isNotRequiredTypedDictVariable(evaluator, symbol) {
 }
 function isReadOnlyTypedDictVariable(evaluator, symbol) {
     return symbol.getDeclarations().some((decl) => {
-        if (decl.type !== 1 /* Variable */ || !decl.typeAnnotationNode) {
+        if (decl.type !== 1 /* DeclarationType.Variable */ || !decl.typeAnnotationNode) {
             return false;
         }
         const annotatedType = evaluator.getTypeOfExpressionExpectingType(decl.typeAnnotationNode, {