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

package/dist/commands/dumpFileDebugInfoCommand.js

@@ -122,9 +122,9 @@ function getTypeEvaluatorString(file, evaluator, results, start, end, cacheOnly)
         return 'N/A';
     }
     const set = new Set();
-    if (node.nodeType === 38 /* Name */) {
+    if (node.nodeType === 38 /* ParseNodeType.Name */) {
         switch ((_b = node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) {
-            case 10 /* Class */: {
+            case 10 /* ParseNodeType.Class */: {
                 const result = cacheOnly
                     ? evaluator.getCachedType(node.parent.name)
                     : evaluator.getTypeOfClass(node.parent);
@@ -133,7 +133,7 @@ function getTypeEvaluatorString(file, evaluator, results, start, end, cacheOnly)
                 }
                 return stringify(result, replacer);
             }
-            case 28 /* Function */: {
+            case 28 /* ParseNodeType.Function */: {
                 const result = cacheOnly
                     ? evaluator.getCachedType(node.parent.name)
                     : evaluator.getTypeOfFunction(node.parent);
@@ -243,11 +243,11 @@ function getTypeEvaluatorString(file, evaluator, results, start, end, cacheOnly)
 }
 function getVarianceString(type) {
     switch (type) {
-        case 2 /* Invariant */:
+        case 2 /* Variance.Invariant */:
             return 'Invariant';
-        case 3 /* Covariant */:
+        case 3 /* Variance.Covariant */:
             return 'Covariant';
-        case 4 /* Contravariant */:
+        case 4 /* Variance.Contravariant */:
             return 'Contravariant';
         default:
             return `Unknown Value!! (${type})`;
@@ -269,63 +269,63 @@ function getFlagEnumString(enumMap, enumValue) {
     return str.join(',');
 }
 const FunctionTypeFlagsToString = [
-    [8 /* AbstractMethod */, 'AbstractMethod'],
-    [512 /* Async */, 'Async'],
-    [2 /* ClassMethod */, 'ClassMethod'],
-    [1 /* ConstructorMethod */, 'ConstructorMethod'],
-    [32 /* DisableDefaultChecks */, 'DisableDefaultChecks'],
-    [8192 /* Final */, 'Final'],
-    [16 /* Generator */, 'Generator'],
-    [256 /* Overloaded */, 'Overloaded'],
-    [65536 /* ParamSpecValue */, 'ParamSpecValue'],
-    [131072 /* PartiallyEvaluated */, 'PartiallyEvaluated'],
-    [4096 /* PyTypedDefinition */, 'PyTypedDefinition'],
-    [32768 /* SkipArgsKwargsCompatibilityCheck */, 'SkipArgsKwargsCompatibilityCheck'],
-    [4 /* StaticMethod */, 'StaticMethod'],
-    [2048 /* StubDefinition */, 'StubDefinition'],
-    [64 /* SynthesizedMethod */, 'SynthesizedMethod'],
-    [16384 /* UnannotatedParams */, 'UnannotatedParams'],
+    [8 /* FunctionTypeFlags.AbstractMethod */, 'AbstractMethod'],
+    [512 /* FunctionTypeFlags.Async */, 'Async'],
+    [2 /* FunctionTypeFlags.ClassMethod */, 'ClassMethod'],
+    [1 /* FunctionTypeFlags.ConstructorMethod */, 'ConstructorMethod'],
+    [32 /* FunctionTypeFlags.DisableDefaultChecks */, 'DisableDefaultChecks'],
+    [8192 /* FunctionTypeFlags.Final */, 'Final'],
+    [16 /* FunctionTypeFlags.Generator */, 'Generator'],
+    [256 /* FunctionTypeFlags.Overloaded */, 'Overloaded'],
+    [65536 /* FunctionTypeFlags.ParamSpecValue */, 'ParamSpecValue'],
+    [131072 /* FunctionTypeFlags.PartiallyEvaluated */, 'PartiallyEvaluated'],
+    [4096 /* FunctionTypeFlags.PyTypedDefinition */, 'PyTypedDefinition'],
+    [32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */, 'SkipArgsKwargsCompatibilityCheck'],
+    [4 /* FunctionTypeFlags.StaticMethod */, 'StaticMethod'],
+    [2048 /* FunctionTypeFlags.StubDefinition */, 'StubDefinition'],
+    [64 /* FunctionTypeFlags.SynthesizedMethod */, 'SynthesizedMethod'],
+    [16384 /* FunctionTypeFlags.UnannotatedParams */, 'UnannotatedParams'],
 ];
 function getFunctionTypeFlagsString(flags) {
     return getFlagEnumString(FunctionTypeFlagsToString, flags);
 }
 const ClassTypeFlagsToString = [
-    [1 /* BuiltInClass */, 'BuiltInClass'],
-    [256 /* CanOmitDictValues */, 'CanOmitDictValues'],
-    [4194304 /* ClassProperty */, 'ClassProperty'],
-    [4 /* DataClass */, 'DataClass'],
-    [2097152 /* DataClassKeywordOnlyParams */, 'DataClassKeywordOnlyParams'],
-    [8388608 /* DefinedInStub */, 'DefinedInStub'],
-    [1048576 /* EnumClass */, 'EnumClass'],
-    [4096 /* Final */, 'Final'],
-    [8 /* FrozenDataClass */, 'FrozenDataClass'],
-    [33554432 /* GenerateDataClassSlots */, 'GenerateDataClassSlots'],
-    [262144 /* HasCustomClassGetItem */, 'HasCustomClassGetItem'],
-    [131072 /* PartiallyEvaluated */, 'PartiallyEvaluated'],
-    [2048 /* PropertyClass */, 'PropertyClass'],
-    [8192 /* ProtocolClass */, 'ProtocolClass'],
-    [16384 /* PseudoGenericClass */, 'PseudoGenericClass'],
-    [16777216 /* ReadOnlyInstanceVariables */, 'ReadOnlyInstanceVariables'],
-    [32768 /* RuntimeCheckable */, 'RuntimeCheckable'],
-    [32 /* SkipSynthesizedDataClassEq */, 'SkipSynthesizedDataClassEq'],
-    [16 /* SkipSynthesizedDataClassInit */, 'SkipSynthesizedDataClassInit'],
-    [2 /* SpecialBuiltIn */, 'SpecialBuiltIn'],
-    [1024 /* SupportsAbstractMethods */, 'SupportsAbstractMethods'],
-    [67108864 /* SynthesizeDataClassUnsafeHash */, 'SynthesizeDataClassUnsafeHash'],
-    [64 /* SynthesizedDataClassOrder */, 'SynthesizedDataClassOrder'],
-    [524288 /* TupleClass */, 'TupleClass'],
-    [128 /* TypedDictClass */, 'TypedDictClass'],
-    [65536 /* TypingExtensionClass */, 'TypingExtensionClass'],
+    [1 /* ClassTypeFlags.BuiltInClass */, 'BuiltInClass'],
+    [256 /* ClassTypeFlags.CanOmitDictValues */, 'CanOmitDictValues'],
+    [4194304 /* ClassTypeFlags.ClassProperty */, 'ClassProperty'],
+    [4 /* ClassTypeFlags.DataClass */, 'DataClass'],
+    [2097152 /* ClassTypeFlags.DataClassKeywordOnlyParams */, 'DataClassKeywordOnlyParams'],
+    [8388608 /* ClassTypeFlags.DefinedInStub */, 'DefinedInStub'],
+    [1048576 /* ClassTypeFlags.EnumClass */, 'EnumClass'],
+    [4096 /* ClassTypeFlags.Final */, 'Final'],
+    [8 /* ClassTypeFlags.FrozenDataClass */, 'FrozenDataClass'],
+    [33554432 /* ClassTypeFlags.GenerateDataClassSlots */, 'GenerateDataClassSlots'],
+    [262144 /* ClassTypeFlags.HasCustomClassGetItem */, 'HasCustomClassGetItem'],
+    [131072 /* ClassTypeFlags.PartiallyEvaluated */, 'PartiallyEvaluated'],
+    [2048 /* ClassTypeFlags.PropertyClass */, 'PropertyClass'],
+    [8192 /* ClassTypeFlags.ProtocolClass */, 'ProtocolClass'],
+    [16384 /* ClassTypeFlags.PseudoGenericClass */, 'PseudoGenericClass'],
+    [16777216 /* ClassTypeFlags.ReadOnlyInstanceVariables */, 'ReadOnlyInstanceVariables'],
+    [32768 /* ClassTypeFlags.RuntimeCheckable */, 'RuntimeCheckable'],
+    [32 /* ClassTypeFlags.SkipSynthesizedDataClassEq */, 'SkipSynthesizedDataClassEq'],
+    [16 /* ClassTypeFlags.SkipSynthesizedDataClassInit */, 'SkipSynthesizedDataClassInit'],
+    [2 /* ClassTypeFlags.SpecialBuiltIn */, 'SpecialBuiltIn'],
+    [1024 /* ClassTypeFlags.SupportsAbstractMethods */, 'SupportsAbstractMethods'],
+    [67108864 /* ClassTypeFlags.SynthesizeDataClassUnsafeHash */, 'SynthesizeDataClassUnsafeHash'],
+    [64 /* ClassTypeFlags.SynthesizedDataClassOrder */, 'SynthesizedDataClassOrder'],
+    [524288 /* ClassTypeFlags.TupleClass */, 'TupleClass'],
+    [128 /* ClassTypeFlags.TypedDictClass */, 'TypedDictClass'],
+    [65536 /* ClassTypeFlags.TypingExtensionClass */, 'TypingExtensionClass'],
 ];
 function getClassTypeFlagsString(flags) {
     return getFlagEnumString(ClassTypeFlagsToString, flags);
 }
 function getTypeFlagsString(flags) {
     const str = [];
-    if (flags & 1 /* Instantiable */) {
+    if (flags & 1 /* TypeFlags.Instantiable */) {
         str.push('Instantiable');
     }
-    if (flags & 2 /* Instance */) {
+    if (flags & 2 /* TypeFlags.Instance */) {
         str.push('Instance');
     }
     if (str.length === 0)
@@ -334,30 +334,30 @@ function getTypeFlagsString(flags) {
 }
 function getTypeCategoryString(typeCategory, type) {
     switch (typeCategory) {
-        case 0 /* Unbound */:
+        case 0 /* TypeCategory.Unbound */:
             return 'Unbound';
-        case 1 /* Unknown */:
+        case 1 /* TypeCategory.Unknown */:
             return 'Unknown';
-        case 2 /* Any */:
+        case 2 /* TypeCategory.Any */:
             return 'Any';
-        case 3 /* Never */:
+        case 3 /* TypeCategory.Never */:
             return 'Never';
-        case 4 /* Function */:
+        case 4 /* TypeCategory.Function */:
             return 'Function';
-        case 5 /* OverloadedFunction */:
+        case 5 /* TypeCategory.OverloadedFunction */:
             return 'OverloadedFunction';
-        case 6 /* Class */:
+        case 6 /* TypeCategory.Class */:
             if (types_1.TypeBase.isInstantiable(type)) {
                 return 'Class';
             }
             else {
                 return 'Object';
             }
-        case 7 /* Module */:
+        case 7 /* TypeCategory.Module */:
             return 'Module';
-        case 8 /* Union */:
+        case 8 /* TypeCategory.Union */:
             return 'Union';
-        case 9 /* TypeVar */:
+        case 9 /* TypeCategory.TypeVar */:
             return 'TypeVar';
         default:
             return `Unknown Value!! (${typeCategory})`;
@@ -719,21 +719,21 @@ function getTypeParameterCategoryString(type) {
 }
 function getParameterCategoryString(type) {
     switch (type) {
-        case 0 /* Simple */:
+        case 0 /* ParameterCategory.Simple */:
             return 'Simple';
-        case 1 /* ArgsList */:
+        case 1 /* ParameterCategory.ArgsList */:
             return 'VarArgList';
-        case 2 /* KwargsDict */:
+        case 2 /* ParameterCategory.KwargsDict */:
             return 'VarArgDictionary';
     }
 }
 function getArgumentCategoryString(type) {
     switch (type) {
-        case 0 /* Simple */:
+        case 0 /* ArgumentCategory.Simple */:
             return 'Simple';
-        case 1 /* UnpackedList */:
+        case 1 /* ArgumentCategory.UnpackedList */:
             return 'UnpackedList';
-        case 2 /* UnpackedDictionary */:
+        case 2 /* ArgumentCategory.UnpackedDictionary */:
             return 'UnpackedDictionary';
         default:
             return `Unknown Value!! (${type})`;
@@ -741,35 +741,35 @@ function getArgumentCategoryString(type) {
 }
 function getErrorExpressionCategoryString(type) {
     switch (type) {
-        case 0 /* MissingIn */:
+        case 0 /* ErrorExpressionCategory.MissingIn */:
             return 'MissingIn';
-        case 1 /* MissingElse */:
+        case 1 /* ErrorExpressionCategory.MissingElse */:
             return 'MissingElse';
-        case 2 /* MissingExpression */:
+        case 2 /* ErrorExpressionCategory.MissingExpression */:
             return 'MissingExpression';
-        case 3 /* MissingIndexOrSlice */:
+        case 3 /* ErrorExpressionCategory.MissingIndexOrSlice */:
             return 'MissingIndexOrSlice';
-        case 4 /* MissingDecoratorCallName */:
+        case 4 /* ErrorExpressionCategory.MissingDecoratorCallName */:
             return 'MissingDecoratorCallName';
-        case 5 /* MissingCallCloseParen */:
+        case 5 /* ErrorExpressionCategory.MissingCallCloseParen */:
             return 'MissingCallCloseParen';
-        case 6 /* MissingIndexCloseBracket */:
+        case 6 /* ErrorExpressionCategory.MissingIndexCloseBracket */:
             return 'MissingIndexCloseBracket';
-        case 7 /* MissingMemberAccessName */:
+        case 7 /* ErrorExpressionCategory.MissingMemberAccessName */:
             return 'MissingMemberAccessName';
-        case 8 /* MissingTupleCloseParen */:
+        case 8 /* ErrorExpressionCategory.MissingTupleCloseParen */:
             return 'MissingTupleCloseParen';
-        case 9 /* MissingListCloseBracket */:
+        case 9 /* ErrorExpressionCategory.MissingListCloseBracket */:
             return 'MissingListCloseBracket';
-        case 10 /* MissingFunctionParameterList */:
+        case 10 /* ErrorExpressionCategory.MissingFunctionParameterList */:
             return 'MissingFunctionParameterList';
-        case 11 /* MissingPattern */:
+        case 11 /* ErrorExpressionCategory.MissingPattern */:
             return 'MissingPattern';
-        case 12 /* MissingPatternSubject */:
+        case 12 /* ErrorExpressionCategory.MissingPatternSubject */:
             return 'MissingPatternSubject';
-        case 13 /* MissingDictValue */:
+        case 13 /* ErrorExpressionCategory.MissingDictValue */:
             return 'MissingDictValue';
-        case 14 /* MaxDepthExceeded */:
+        case 14 /* ErrorExpressionCategory.MaxDepthExceeded */:
             return 'MaxDepthExceeded';
         default:
             return `Unknown Value!! (${type})`;
@@ -806,51 +806,51 @@ function getTextSpanString(span, lines) {
 }
 function getTokenTypeString(type) {
     switch (type) {
-        case 0 /* Invalid */:
+        case 0 /* TokenType.Invalid */:
             return 'Invalid';
-        case 1 /* EndOfStream */:
+        case 1 /* TokenType.EndOfStream */:
             return 'EndOfStream';
-        case 2 /* NewLine */:
+        case 2 /* TokenType.NewLine */:
             return 'NewLine';
-        case 3 /* Indent */:
+        case 3 /* TokenType.Indent */:
             return 'Indent';
-        case 4 /* Dedent */:
+        case 4 /* TokenType.Dedent */:
             return 'Dedent';
-        case 5 /* String */:
+        case 5 /* TokenType.String */:
             return 'String';
-        case 6 /* Number */:
+        case 6 /* TokenType.Number */:
             return 'Number';
-        case 7 /* Identifier */:
+        case 7 /* TokenType.Identifier */:
             return 'Identifier';
-        case 8 /* Keyword */:
+        case 8 /* TokenType.Keyword */:
             return 'Keyword';
-        case 9 /* Operator */:
+        case 9 /* TokenType.Operator */:
             return 'Operator';
-        case 10 /* Colon */:
+        case 10 /* TokenType.Colon */:
             return 'Colon';
-        case 11 /* Semicolon */:
+        case 11 /* TokenType.Semicolon */:
             return 'Semicolon';
-        case 12 /* Comma */:
+        case 12 /* TokenType.Comma */:
             return 'Comma';
-        case 13 /* OpenParenthesis */:
+        case 13 /* TokenType.OpenParenthesis */:
             return 'OpenParenthesis';
-        case 14 /* CloseParenthesis */:
+        case 14 /* TokenType.CloseParenthesis */:
             return 'CloseParenthesis';
-        case 15 /* OpenBracket */:
+        case 15 /* TokenType.OpenBracket */:
             return 'OpenBracket';
-        case 16 /* CloseBracket */:
+        case 16 /* TokenType.CloseBracket */:
             return 'CloseBracket';
-        case 17 /* OpenCurlyBrace */:
+        case 17 /* TokenType.OpenCurlyBrace */:
             return 'OpenCurlyBrace';
-        case 18 /* CloseCurlyBrace */:
+        case 18 /* TokenType.CloseCurlyBrace */:
             return 'CloseCurlyBrace';
-        case 19 /* Ellipsis */:
+        case 19 /* TokenType.Ellipsis */:
             return 'Ellipsis';
-        case 20 /* Dot */:
+        case 20 /* TokenType.Dot */:
             return 'Dot';
-        case 21 /* Arrow */:
+        case 21 /* TokenType.Arrow */:
             return 'Arrow';
-        case 22 /* Backtick */:
+        case 22 /* TokenType.Backtick */:
             return 'Backtick';
         default:
             return `Unknown Value!! (${type})`;
@@ -858,13 +858,13 @@ function getTokenTypeString(type) {
 }
 function getNewLineTypeString(type) {
     switch (type) {
-        case 0 /* CarriageReturn */:
+        case 0 /* NewLineType.CarriageReturn */:
             return 'CarriageReturn';
-        case 1 /* LineFeed */:
+        case 1 /* NewLineType.LineFeed */:
             return 'LineFeed';
-        case 2 /* CarriageReturnLineFeed */:
+        case 2 /* NewLineType.CarriageReturnLineFeed */:
             return 'CarriageReturnLineFeed';
-        case 3 /* Implied */:
+        case 3 /* NewLineType.Implied */:
             return 'Implied';
         default:
             return `Unknown Value!! (${type})`;
@@ -872,91 +872,91 @@ function getNewLineTypeString(type) {
 }
 function getOperatorTypeString(type) {
     switch (type) {
-        case 0 /* Add */:
+        case 0 /* OperatorType.Add */:
             return 'Add';
-        case 1 /* AddEqual */:
+        case 1 /* OperatorType.AddEqual */:
             return 'AddEqual';
-        case 2 /* Assign */:
+        case 2 /* OperatorType.Assign */:
             return 'Assign';
-        case 3 /* BitwiseAnd */:
+        case 3 /* OperatorType.BitwiseAnd */:
             return 'BitwiseAnd';
-        case 4 /* BitwiseAndEqual */:
+        case 4 /* OperatorType.BitwiseAndEqual */:
             return 'BitwiseAndEqual';
-        case 5 /* BitwiseInvert */:
+        case 5 /* OperatorType.BitwiseInvert */:
             return 'BitwiseInvert';
-        case 6 /* BitwiseOr */:
+        case 6 /* OperatorType.BitwiseOr */:
             return 'BitwiseOr';
-        case 7 /* BitwiseOrEqual */:
+        case 7 /* OperatorType.BitwiseOrEqual */:
             return 'BitwiseOrEqual';
-        case 8 /* BitwiseXor */:
+        case 8 /* OperatorType.BitwiseXor */:
             return 'BitwiseXor';
-        case 9 /* BitwiseXorEqual */:
+        case 9 /* OperatorType.BitwiseXorEqual */:
             return 'BitwiseXorEqual';
-        case 10 /* Divide */:
+        case 10 /* OperatorType.Divide */:
             return 'Divide';
-        case 11 /* DivideEqual */:
+        case 11 /* OperatorType.DivideEqual */:
             return 'DivideEqual';
-        case 12 /* Equals */:
+        case 12 /* OperatorType.Equals */:
             return 'Equals';
-        case 13 /* FloorDivide */:
+        case 13 /* OperatorType.FloorDivide */:
             return 'FloorDivide';
-        case 14 /* FloorDivideEqual */:
+        case 14 /* OperatorType.FloorDivideEqual */:
             return 'FloorDivideEqual';
-        case 15 /* GreaterThan */:
+        case 15 /* OperatorType.GreaterThan */:
             return 'GreaterThan';
-        case 16 /* GreaterThanOrEqual */:
+        case 16 /* OperatorType.GreaterThanOrEqual */:
             return 'GreaterThanOrEqual';
-        case 17 /* LeftShift */:
+        case 17 /* OperatorType.LeftShift */:
             return 'LeftShift';
-        case 18 /* LeftShiftEqual */:
+        case 18 /* OperatorType.LeftShiftEqual */:
             return 'LeftShiftEqual';
-        case 19 /* LessOrGreaterThan */:
+        case 19 /* OperatorType.LessOrGreaterThan */:
             return 'LessOrGreaterThan';
-        case 20 /* LessThan */:
+        case 20 /* OperatorType.LessThan */:
             return 'LessThan';
-        case 21 /* LessThanOrEqual */:
+        case 21 /* OperatorType.LessThanOrEqual */:
             return 'LessThanOrEqual';
-        case 22 /* MatrixMultiply */:
+        case 22 /* OperatorType.MatrixMultiply */:
             return 'MatrixMultiply';
-        case 23 /* MatrixMultiplyEqual */:
+        case 23 /* OperatorType.MatrixMultiplyEqual */:
             return 'MatrixMultiplyEqual';
-        case 24 /* Mod */:
+        case 24 /* OperatorType.Mod */:
             return 'Mod';
-        case 25 /* ModEqual */:
+        case 25 /* OperatorType.ModEqual */:
             return 'ModEqual';
-        case 26 /* Multiply */:
+        case 26 /* OperatorType.Multiply */:
             return 'Multiply';
-        case 27 /* MultiplyEqual */:
+        case 27 /* OperatorType.MultiplyEqual */:
             return 'MultiplyEqual';
-        case 28 /* NotEquals */:
+        case 28 /* OperatorType.NotEquals */:
             return 'NotEquals';
-        case 29 /* Power */:
+        case 29 /* OperatorType.Power */:
             return 'Power';
-        case 30 /* PowerEqual */:
+        case 30 /* OperatorType.PowerEqual */:
             return 'PowerEqual';
-        case 31 /* RightShift */:
+        case 31 /* OperatorType.RightShift */:
             return 'RightShift';
-        case 32 /* RightShiftEqual */:
+        case 32 /* OperatorType.RightShiftEqual */:
             return 'RightShiftEqual';
-        case 33 /* Subtract */:
+        case 33 /* OperatorType.Subtract */:
             return 'Subtract';
-        case 34 /* SubtractEqual */:
+        case 34 /* OperatorType.SubtractEqual */:
             return 'SubtractEqual';
-        case 35 /* Walrus */:
+        case 35 /* OperatorType.Walrus */:
             return 'Walrus';
-        case 36 /* And */:
+        case 36 /* OperatorType.And */:
             return 'And';
-        case 37 /* Or */:
+        case 37 /* OperatorType.Or */:
             return 'Or';
-        case 38 /* Not */:
+        case 38 /* OperatorType.Not */:
             return 'Not';
-        case 39 /* Is */:
+        case 39 /* OperatorType.Is */:
             return 'Is';
-        case 40 /* IsNot */:
+        case 40 /* OperatorType.IsNot */:
             return 'IsNot';
-        case 41 /* In */:
+        case 41 /* OperatorType.In */:
             return 'In';
-        case 42 /* NotIn */:
+        case 42 /* OperatorType.NotIn */:
             return 'NotIn';
         default:
             return `Unknown Value!! (${type})`;
@@ -964,92 +964,92 @@ function getOperatorTypeString(type) {
 }
 function getKeywordTypeString(type) {
     switch (type) {
-        case 0 /* And */:
+        case 0 /* KeywordType.And */:
             return 'And';
-        case 1 /* As */:
+        case 1 /* KeywordType.As */:
             return 'As';
-        case 2 /* Assert */:
+        case 2 /* KeywordType.Assert */:
             return 'Assert';
-        case 3 /* Async */:
+        case 3 /* KeywordType.Async */:
             return 'Async';
-        case 4 /* Await */:
+        case 4 /* KeywordType.Await */:
             return 'Await';
-        case 5 /* Break */:
+        case 5 /* KeywordType.Break */:
             return 'Break';
-        case 7 /* Class */:
+        case 7 /* KeywordType.Class */:
             return 'Class';
-        case 8 /* Continue */:
+        case 8 /* KeywordType.Continue */:
             return 'Continue';
-        case 9 /* Debug */:
+        case 9 /* KeywordType.Debug */:
             return 'Debug';
-        case 10 /* Def */:
+        case 10 /* KeywordType.Def */:
             return 'Def';
-        case 11 /* Del */:
+        case 11 /* KeywordType.Del */:
             return 'Del';
-        case 12 /* Elif */:
+        case 12 /* KeywordType.Elif */:
             return 'Elif';
-        case 13 /* Else */:
+        case 13 /* KeywordType.Else */:
             return 'Else';
-        case 14 /* Except */:
+        case 14 /* KeywordType.Except */:
             return 'Except';
-        case 15 /* False */:
+        case 15 /* KeywordType.False */:
             return 'False';
-        case 16 /* Finally */:
+        case 16 /* KeywordType.Finally */:
             return 'Finally';
-        case 17 /* For */:
+        case 17 /* KeywordType.For */:
             return 'For';
-        case 18 /* From */:
+        case 18 /* KeywordType.From */:
             return 'From';
-        case 19 /* Global */:
+        case 19 /* KeywordType.Global */:
             return 'Global';
-        case 20 /* If */:
+        case 20 /* KeywordType.If */:
             return 'If';
-        case 21 /* Import */:
+        case 21 /* KeywordType.Import */:
             return 'Import';
-        case 22 /* In */:
+        case 22 /* KeywordType.In */:
             return 'In';
-        case 23 /* Is */:
+        case 23 /* KeywordType.Is */:
             return 'Is';
-        case 24 /* Lambda */:
+        case 24 /* KeywordType.Lambda */:
             return 'Lambda';
-        case 26 /* None */:
+        case 26 /* KeywordType.None */:
             return 'None';
-        case 27 /* Nonlocal */:
+        case 27 /* KeywordType.Nonlocal */:
             return 'Nonlocal';
-        case 28 /* Not */:
+        case 28 /* KeywordType.Not */:
             return 'Not';
-        case 29 /* Or */:
+        case 29 /* KeywordType.Or */:
             return 'Or';
-        case 30 /* Pass */:
+        case 30 /* KeywordType.Pass */:
             return 'Pass';
-        case 31 /* Raise */:
+        case 31 /* KeywordType.Raise */:
             return 'Raise';
-        case 32 /* Return */:
+        case 32 /* KeywordType.Return */:
             return 'Return';
-        case 33 /* True */:
+        case 33 /* KeywordType.True */:
             return 'True';
-        case 34 /* Try */:
+        case 34 /* KeywordType.Try */:
             return 'Try';
-        case 36 /* While */:
+        case 36 /* KeywordType.While */:
             return 'While';
-        case 37 /* With */:
+        case 37 /* KeywordType.With */:
             return 'With';
-        case 38 /* Yield */:
+        case 38 /* KeywordType.Yield */:
             return 'Yield';
         default:
             return `Unknown Value!! (${type})`;
     }
 }
 const StringTokenFlagsStrings = [
-    [32 /* Bytes */, 'Bytes'],
-    [2 /* DoubleQuote */, 'DoubleQuote'],
-    [131072 /* ExceedsMaxSize */, 'ExceedsMaxSize'],
-    [64 /* Format */, 'Format'],
-    [8 /* Raw */, 'Raw'],
-    [1 /* SingleQuote */, 'SingleQuote'],
-    [4 /* Triplicate */, 'Triplicate'],
-    [16 /* Unicode */, 'Unicode'],
-    [65536 /* Unterminated */, 'Unterminated'],
+    [32 /* StringTokenFlags.Bytes */, 'Bytes'],
+    [2 /* StringTokenFlags.DoubleQuote */, 'DoubleQuote'],
+    [131072 /* StringTokenFlags.ExceedsMaxSize */, 'ExceedsMaxSize'],
+    [64 /* StringTokenFlags.Format */, 'Format'],
+    [8 /* StringTokenFlags.Raw */, 'Raw'],
+    [1 /* StringTokenFlags.SingleQuote */, 'SingleQuote'],
+    [4 /* StringTokenFlags.Triplicate */, 'Triplicate'],
+    [16 /* StringTokenFlags.Unicode */, 'Unicode'],
+    [65536 /* StringTokenFlags.Unterminated */, 'Unterminated'],
 ];
 function getStringTokenFlagsString(flags) {
     return getFlagEnumString(StringTokenFlagsStrings, flags);