@zzzen/pyright-internal 1.2.0-dev.20220925 → 1.2.0-dev.20221009

package/dist/commands/dumpFileDebugInfoCommand.js

@@ -0,0 +1,983 @@
+"use strict";
+/*
+ * dumpFileDebugInfoCommand.ts
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Dump various token/node/type info
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DumpFileDebugInfoCommand = void 0;
+const analyzerNodeInfo_1 = require("../analyzer/analyzerNodeInfo");
+const parseTreeUtils_1 = require("../analyzer/parseTreeUtils");
+const parseTreeWalker_1 = require("../analyzer/parseTreeWalker");
+const types_1 = require("../analyzer/types");
+const cancellationUtils_1 = require("../common/cancellationUtils");
+const core_1 = require("../common/core");
+const positionUtils_1 = require("../common/positionUtils");
+const textRange_1 = require("../common/textRange");
+const parseNodes_1 = require("../parser/parseNodes");
+class DumpFileDebugInfoCommand {
+    constructor(_ls) {
+        this._ls = _ls;
+    }
+    async execute(params, token) {
+        (0, cancellationUtils_1.throwIfCancellationRequested)(token);
+        if (!params.arguments || params.arguments.length < 2) {
+            return [];
+        }
+        const filePath = params.arguments[0];
+        const kind = params.arguments[1];
+        const workspace = await this._ls.getWorkspaceForFile(filePath);
+        const parseResults = workspace.serviceInstance.getParseResult(filePath);
+        if (!parseResults) {
+            return [];
+        }
+        const output = [];
+        const collectingConsole = {
+            info: (m) => {
+                output.push(m);
+            },
+            log: (m) => {
+                output.push(m);
+            },
+            error: (m) => {
+                output.push(m);
+            },
+            warn: (m) => {
+                output.push(m);
+            },
+        };
+        collectingConsole.info(`* Dump debug info for '${filePath}'`);
+        switch (kind) {
+            case 'tokens': {
+                collectingConsole.info(`* Token info (${parseResults.tokenizerOutput.tokens.count} tokens)`);
+                for (let i = 0; i < parseResults.tokenizerOutput.tokens.count; i++) {
+                    const token = parseResults.tokenizerOutput.tokens.getItemAt(i);
+                    collectingConsole.info(`[${i}] ${getTokenString(filePath, token, parseResults.tokenizerOutput.lines)}`);
+                }
+                break;
+            }
+            case 'nodes': {
+                collectingConsole.info(`* Node info`);
+                const dumper = new TreeDumper(filePath, parseResults.tokenizerOutput.lines);
+                dumper.walk(parseResults.parseTree);
+                collectingConsole.info(dumper.output);
+                break;
+            }
+            case 'types': {
+                const evaluator = workspace.serviceInstance.getEvaluator();
+                const start = params.arguments[2];
+                const end = params.arguments[3];
+                if (!evaluator || !start || !end) {
+                    return [];
+                }
+                collectingConsole.info(`* Type info`);
+                collectingConsole.info(`${getTypeEvaluatorString(filePath, evaluator, parseResults, start, end)}`);
+                break;
+            }
+            case 'cachedtypes': {
+                const evaluator = workspace.serviceInstance.getEvaluator();
+                const start = params.arguments[2];
+                const end = params.arguments[3];
+                if (!evaluator || !start || !end) {
+                    return [];
+                }
+                collectingConsole.info(`* Cached Type info`);
+                collectingConsole.info(`${getTypeEvaluatorString(filePath, evaluator, parseResults, start, end, true)}`);
+                break;
+            }
+            case 'codeflowgraph': {
+                const evaluator = workspace.serviceInstance.getEvaluator();
+                const offset = params.arguments[2];
+                if (!evaluator || offset === undefined) {
+                    return [];
+                }
+                const node = (0, parseTreeUtils_1.findNodeByOffset)(parseResults.parseTree, offset);
+                if (!node) {
+                    return [];
+                }
+                const flowNode = (0, analyzerNodeInfo_1.getFlowNode)(node);
+                if (!flowNode) {
+                    return [];
+                }
+                collectingConsole.info(`* CodeFlow Graph`);
+                evaluator.printControlFlowGraph(flowNode, undefined, 'Dump CodeFlowGraph', collectingConsole);
+            }
+        }
+        // Print all of the output in one message so the trace log is smaller.
+        this._ls.console.info(output.join('\n'));
+    }
+}
+exports.DumpFileDebugInfoCommand = DumpFileDebugInfoCommand;
+function stringify(value, replacer) {
+    const json = JSON.stringify(value, replacer, 2);
+    // Unescape any paths so VS code shows them as clickable.
+    return json.replace(/\\\\/g, '\\');
+}
+function getTypeEvaluatorString(file, evaluator, results, start, end, cacheOnly) {
+    var _a, _b;
+    const dumper = new TreeDumper(file, results.tokenizerOutput.lines);
+    const node = (_a = (0, parseTreeUtils_1.findNodeByOffset)(results.parseTree, start)) !== null && _a !== void 0 ? _a : (0, parseTreeUtils_1.findNodeByOffset)(results.parseTree, end);
+    if (!node) {
+        return 'N/A';
+    }
+    const set = new Set();
+    if (node.nodeType === 38 /* Name */) {
+        switch ((_b = node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) {
+            case 10 /* Class */: {
+                const result = cacheOnly
+                    ? evaluator.getCachedType(node.parent.name)
+                    : evaluator.getTypeOfClass(node.parent);
+                if (!result) {
+                    return 'N/A';
+                }
+                return stringify(result, replacer);
+            }
+            case 28 /* Function */: {
+                const result = cacheOnly
+                    ? evaluator.getCachedType(node.parent.name)
+                    : evaluator.getTypeOfFunction(node.parent);
+                if (!result) {
+                    return 'N/A';
+                }
+                return stringify(result, replacer);
+            }
+        }
+    }
+    const range = textRange_1.TextRange.fromBounds(start, end);
+    const expr = getExpressionNodeWithRange(node, range);
+    if (!expr) {
+        return 'N/A';
+    }
+    const sb = `Expression node found at ${getTextSpanString(expr, results.tokenizerOutput.lines)} from the given span ${getTextSpanString(range, results.tokenizerOutput.lines)}\r\n`;
+    const result = cacheOnly ? evaluator.getCachedType(expr) : evaluator.getType(expr);
+    if (!result) {
+        return sb + 'No result';
+    }
+    return sb + stringify(result, replacer);
+    function getExpressionNodeWithRange(node, range) {
+        // find best expression node that contains both start and end.
+        let current = node;
+        while (current && !textRange_1.TextRange.containsRange(current, range)) {
+            current = current.parent;
+        }
+        if (!current) {
+            return undefined;
+        }
+        while (!(0, parseNodes_1.isExpressionNode)(current)) {
+            current = current.parent;
+        }
+        return current;
+    }
+    function replacer(key, value) {
+        if (value === undefined) {
+            return undefined;
+        }
+        if (!(0, core_1.isNumber)(value) && !(0, core_1.isString)(value)) {
+            if (set.has(value)) {
+                if (isClassType(value)) {
+                    return `<cycle> class '${value.details.fullName}' typeSourceId:${value.details.typeSourceId}`;
+                }
+                if (isFunctionType(value)) {
+                    return `<cycle> function '${value.details.fullName}' parameter count:${value.details.parameters.length}`;
+                }
+                if (isTypeVarType(value)) {
+                    return `<cycle> function '${value.details.name}' scope id:${value.nameWithScope}`;
+                }
+                return undefined;
+            }
+            else {
+                set.add(value);
+            }
+        }
+        if (isTypeBase(this) && key === 'category') {
+            return getTypeCategoryString(value, this);
+        }
+        if (isTypeBase(this) && key === 'flags') {
+            return getTypeFlagsString(value);
+        }
+        if (isClassDetail(this) && key === 'flags') {
+            return getClassTypeFlagsString(value);
+        }
+        if (isFunctionDetail(this) && key === 'flags') {
+            return getFunctionTypeFlagsString(value);
+        }
+        if (isTypeVarDetails(this) && key === 'variance') {
+            return getVarianceString(value);
+        }
+        if (isParamSpecEntry(this) && key === 'category') {
+            return getParameterCategoryString(value);
+        }
+        if (value.nodeType && value.id) {
+            dumper.visitNode(value);
+            const output = dumper.output;
+            dumper.reset();
+            return output;
+        }
+        return value;
+    }
+    function isTypeBase(type) {
+        return type.category && type.flags;
+    }
+    function isClassType(type) {
+        return isTypeBase(type) && type.details && isClassDetail(type.details);
+    }
+    function isClassDetail(type) {
+        return (type.name !== undefined && type.fullName !== undefined && type.moduleName !== undefined && type.baseClasses);
+    }
+    function isFunctionType(type) {
+        return isTypeBase(type) && type.details && isFunctionDetail(type.details);
+    }
+    function isFunctionDetail(type) {
+        return (type.name !== undefined && type.fullName !== undefined && type.moduleName !== undefined && type.parameters);
+    }
+    function isTypeVarType(type) {
+        return isTypeBase(type) && type.details && isTypeVarDetails(type.details);
+    }
+    function isTypeVarDetails(type) {
+        return type.name !== undefined && type.constraints && type.variance !== undefined;
+    }
+    function isParamSpecEntry(type) {
+        return type.category && type.type;
+    }
+}
+function getVarianceString(type) {
+    switch (type) {
+        case 2 /* Invariant */:
+            return 'Invariant';
+        case 3 /* Covariant */:
+            return 'Covariant';
+        case 4 /* Contravariant */:
+            return 'Contravariant';
+        default:
+            return `Unknown Value!! (${type})`;
+    }
+}
+function getFlagEnumString(enumMap, enumValue) {
+    const str = [];
+    enumMap.forEach((e) => {
+        if (enumValue & e[0]) {
+            str.push(e[1]);
+        }
+    });
+    if (str.length === 0) {
+        if (enumValue === 0) {
+            return 'None';
+        }
+        return '<Unknown>';
+    }
+    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'],
+    [128 /* SkipConstructorCheck */, 'SkipConstructorCheck'],
+    [4 /* StaticMethod */, 'StaticMethod'],
+    [2048 /* StubDefinition */, 'StubDefinition'],
+    [64 /* SynthesizedMethod */, 'SynthesizedMethod'],
+    [16384 /* UnannotatedParams */, 'UnannotatedParams'],
+    [1024 /* WrapReturnTypeInAwait */, 'WrapReturnTypeInAwait'],
+];
+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'],
+    [512 /* SupportsAbstractMethods */, 'SupportsAbstractMethods'],
+    [67108864 /* SynthesizeDataClassUnsafeHash */, 'SynthesizeDataClassUnsafeHash'],
+    [64 /* SynthesizedDataClassOrder */, 'SynthesizedDataClassOrder'],
+    [524288 /* TupleClass */, 'TupleClass'],
+    [128 /* TypedDictClass */, 'TypedDictClass'],
+    [65536 /* TypingExtensionClass */, 'TypingExtensionClass'],
+];
+function getClassTypeFlagsString(flags) {
+    return getFlagEnumString(ClassTypeFlagsToString, flags);
+}
+function getTypeFlagsString(flags) {
+    const str = [];
+    if (flags & 1 /* Instantiable */) {
+        str.push('Instantiable');
+    }
+    if (flags & 2 /* Instance */) {
+        str.push('Instance');
+    }
+    if (str.length === 0)
+        return 'None';
+    return str.join(',');
+}
+function getTypeCategoryString(typeCategory, type) {
+    switch (typeCategory) {
+        case 0 /* Unbound */:
+            return 'Unbound';
+        case 1 /* Unknown */:
+            return 'Unknown';
+        case 2 /* Any */:
+            return 'Any';
+        case 3 /* None */:
+            return 'None';
+        case 4 /* Never */:
+            return 'Never';
+        case 5 /* Function */:
+            return 'Function';
+        case 6 /* OverloadedFunction */:
+            return 'OverloadedFunction';
+        case 7 /* Class */:
+            if (types_1.TypeBase.isInstantiable(type)) {
+                return 'Class';
+            }
+            else {
+                return 'Object';
+            }
+        case 8 /* Module */:
+            return 'Module';
+        case 9 /* Union */:
+            return 'Union';
+        case 10 /* TypeVar */:
+            return 'TypeVar';
+        default:
+            return `Unknown Value!! (${typeCategory})`;
+    }
+}
+class TreeDumper extends parseTreeWalker_1.ParseTreeWalker {
+    constructor(_file, _lines) {
+        super();
+        this._file = _file;
+        this._lines = _lines;
+        this._indentation = '';
+        this._output = '';
+    }
+    get output() {
+        return this._output;
+    }
+    walk(node) {
+        const childrenToWalk = this.visitNode(node);
+        if (childrenToWalk.length > 0) {
+            this._indentation += '  ';
+            this.walkMultiple(childrenToWalk);
+            this._indentation = this._indentation.substr(0, this._indentation.length - 2);
+        }
+    }
+    _log(value) {
+        this._output += `${this._indentation}${value}\r\n`;
+    }
+    _getPrefix(node) {
+        const pos = (0, positionUtils_1.convertOffsetToPosition)(node.start, this._lines);
+        // VS code's output window expects 1 based values, print the line/char with 1 based.
+        return `[${node.id}] '${this._file}:${pos.line + 1}:${pos.character + 1}' => ${(0, parseTreeUtils_1.printParseNodeType)(node.nodeType)} ${getTextSpanString(node, this._lines)} =>`;
+    }
+    reset() {
+        this._indentation = '';
+        this._output = '';
+    }
+    visitArgument(node) {
+        this._log(`${this._getPrefix(node)} ${getArgumentCategoryString(node.argumentCategory)}`);
+        return true;
+    }
+    visitAssert(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitAssignment(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitAssignmentExpression(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitAugmentedAssignment(node) {
+        this._log(`${this._getPrefix(node)} ${getOperatorTypeString(node.operator)}`);
+        return true;
+    }
+    visitAwait(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitBinaryOperation(node) {
+        this._log(`${this._getPrefix(node)} ${getTokenString(this._file, node.operatorToken, this._lines)} ${getOperatorTypeString(node.operator)}} parenthesized:(${node.parenthesized})`);
+        return true;
+    }
+    visitBreak(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitCall(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitClass(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitTernary(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitContinue(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitConstant(node) {
+        this._log(`${this._getPrefix(node)} ${getKeywordTypeString(node.constType)}`);
+        return true;
+    }
+    visitDecorator(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitDel(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitDictionary(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitDictionaryKeyEntry(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitDictionaryExpandEntry(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitError(node) {
+        this._log(`${this._getPrefix(node)} ${getErrorExpressionCategoryString(node.category)}`);
+        return true;
+    }
+    visitEllipsis(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitIf(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitImport(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitImportAs(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitImportFrom(node) {
+        this._log(`${this._getPrefix(node)} wildcard import:(${node.isWildcardImport}) paren:(${node.usesParens}) wildcard token:(${node.wildcardToken ? getTokenString(this._file, node.wildcardToken, this._lines) : 'N/A'}) missing import keyword:(${node.missingImportKeyword})`);
+        return true;
+    }
+    visitImportFromAs(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitIndex(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitExcept(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitFor(node) {
+        this._log(`${this._getPrefix(node)} async:(${node.isAsync})`);
+        return true;
+    }
+    visitFormatString(node) {
+        this._log(`${this._getPrefix(node)} ${getTokenString(this._file, node.token, this._lines)} ${node.value} unescape errors:(${node.hasUnescapeErrors})`);
+        return true;
+    }
+    visitFunction(node) {
+        this._log(`${this._getPrefix(node)} async:(${node.isAsync})`);
+        return true;
+    }
+    visitFunctionAnnotation(node) {
+        this._log(`${this._getPrefix(node)} ellipsis:(${node.isParamListEllipsis})`);
+        return true;
+    }
+    visitGlobal(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitLambda(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitList(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitListComprehension(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitListComprehensionFor(node) {
+        this._log(`${this._getPrefix(node)} async:(${node.isAsync})`);
+        return true;
+    }
+    visitListComprehensionIf(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitMemberAccess(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitModule(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitModuleName(node) {
+        this._log(`${this._getPrefix(node)} leading dots:(${node.leadingDots}) trailing dot:(${node.hasTrailingDot})`);
+        return true;
+    }
+    visitName(node) {
+        this._log(`${this._getPrefix(node)} ${getTokenString(this._file, node.token, this._lines)} ${node.value}`);
+        return true;
+    }
+    visitNonlocal(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitNumber(node) {
+        this._log(`${this._getPrefix(node)} ${node.value} int:(${node.isInteger}) imaginary:(${node.isImaginary})`);
+        return true;
+    }
+    visitParameter(node) {
+        this._log(`${this._getPrefix(node)} ${getParameterCategoryString(node.category)}`);
+        return true;
+    }
+    visitPass(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitRaise(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitReturn(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitSet(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitSlice(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitStatementList(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitString(node) {
+        this._log(`${this._getPrefix(node)} ${getTokenString(this._file, node.token, this._lines)} ${node.value} unescape errors:(${node.hasUnescapeErrors})`);
+        return true;
+    }
+    visitStringList(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitSuite(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitTuple(node) {
+        this._log(`${this._getPrefix(node)} paren:(${node.enclosedInParens})`);
+        return true;
+    }
+    visitTry(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitTypeAnnotation(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitUnaryOperation(node) {
+        this._log(`${this._getPrefix(node)} ${getTokenString(this._file, node.operatorToken, this._lines)} ${getOperatorTypeString(node.operator)}`);
+        return true;
+    }
+    visitUnpack(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitWhile(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitWith(node) {
+        this._log(`${this._getPrefix(node)} async:(${node.isAsync})`);
+        return true;
+    }
+    visitWithItem(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitYield(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+    visitYieldFrom(node) {
+        this._log(`${this._getPrefix(node)}`);
+        return true;
+    }
+}
+function getParameterCategoryString(type) {
+    switch (type) {
+        case 0 /* Simple */:
+            return 'Simple';
+        case 1 /* VarArgList */:
+            return 'VarArgList';
+        case 2 /* VarArgDictionary */:
+            return 'VarArgDictionary';
+    }
+}
+function getArgumentCategoryString(type) {
+    switch (type) {
+        case 0 /* Simple */:
+            return 'Simple';
+        case 1 /* UnpackedList */:
+            return 'UnpackedList';
+        case 2 /* UnpackedDictionary */:
+            return 'UnpackedDictionary';
+        default:
+            return `Unknown Value!! (${type})`;
+    }
+}
+function getErrorExpressionCategoryString(type) {
+    switch (type) {
+        case 0 /* MissingIn */:
+            return 'MissingIn';
+        case 1 /* MissingElse */:
+            return 'MissingElse';
+        case 2 /* MissingExpression */:
+            return 'MissingExpression';
+        case 3 /* MissingIndexOrSlice */:
+            return 'MissingIndexOrSlice';
+        case 4 /* MissingDecoratorCallName */:
+            return 'MissingDecoratorCallName';
+        case 5 /* MissingCallCloseParen */:
+            return 'MissingCallCloseParen';
+        case 6 /* MissingIndexCloseBracket */:
+            return 'MissingIndexCloseBracket';
+        case 7 /* MissingMemberAccessName */:
+            return 'MissingMemberAccessName';
+        case 8 /* MissingTupleCloseParen */:
+            return 'MissingTupleCloseParen';
+        case 9 /* MissingListCloseBracket */:
+            return 'MissingListCloseBracket';
+        case 10 /* MissingFunctionParameterList */:
+            return 'MissingFunctionParameterList';
+        default:
+            return `Unknown Value!! (${type})`;
+    }
+}
+function getTokenString(file, token, lines) {
+    const pos = (0, positionUtils_1.convertOffsetToPosition)(token.start, lines);
+    let str = `'${file}:${pos.line + 1}:${pos.character + 1}' (`;
+    str += getTokenTypeString(token.type);
+    str += getNewLineInfo(token);
+    str += getOperatorInfo(token);
+    str += getKeywordInfo(token);
+    str += getStringTokenFlags(token);
+    str += `, ${getTextSpanString(token, lines)}`;
+    str += ') ';
+    str += JSON.stringify(token);
+    return str;
+    function getNewLineInfo(t) {
+        return t.newLineType ? `, ${getNewLineTypeString(t.newLineType)}` : '';
+    }
+    function getOperatorInfo(t) {
+        return t.operatorType ? `, ${getOperatorTypeString(t.operatorType)}` : '';
+    }
+    function getKeywordInfo(t) {
+        return t.keywordType ? `, ${getKeywordTypeString(t.keywordType)}` : '';
+    }
+    function getStringTokenFlags(t) {
+        return t.flags ? `, [${getStringTokenFlagsString(t.flags)}]` : '';
+    }
+}
+function getTextSpanString(span, lines) {
+    const range = (0, positionUtils_1.convertOffsetsToRange)(span.start, textRange_1.TextRange.getEnd(span), lines);
+    return `(${range.start.line},${range.start.character})-(${range.end.line},${range.end.character})`;
+}
+function getTokenTypeString(type) {
+    switch (type) {
+        case 0 /* Invalid */:
+            return 'Invalid';
+        case 1 /* EndOfStream */:
+            return 'EndOfStream';
+        case 2 /* NewLine */:
+            return 'NewLine';
+        case 3 /* Indent */:
+            return 'Indent';
+        case 4 /* Dedent */:
+            return 'Dedent';
+        case 5 /* String */:
+            return 'String';
+        case 6 /* Number */:
+            return 'Number';
+        case 7 /* Identifier */:
+            return 'Identifier';
+        case 8 /* Keyword */:
+            return 'Keyword';
+        case 9 /* Operator */:
+            return 'Operator';
+        case 10 /* Colon */:
+            return 'Colon';
+        case 11 /* Semicolon */:
+            return 'Semicolon';
+        case 12 /* Comma */:
+            return 'Comma';
+        case 13 /* OpenParenthesis */:
+            return 'OpenParenthesis';
+        case 14 /* CloseParenthesis */:
+            return 'CloseParenthesis';
+        case 15 /* OpenBracket */:
+            return 'OpenBracket';
+        case 16 /* CloseBracket */:
+            return 'CloseBracket';
+        case 17 /* OpenCurlyBrace */:
+            return 'OpenCurlyBrace';
+        case 18 /* CloseCurlyBrace */:
+            return 'CloseCurlyBrace';
+        case 19 /* Ellipsis */:
+            return 'Ellipsis';
+        case 20 /* Dot */:
+            return 'Dot';
+        case 21 /* Arrow */:
+            return 'Arrow';
+        case 22 /* Backtick */:
+            return 'Backtick';
+        default:
+            return `Unknown Value!! (${type})`;
+    }
+}
+function getNewLineTypeString(type) {
+    switch (type) {
+        case 0 /* CarriageReturn */:
+            return 'CarriageReturn';
+        case 1 /* LineFeed */:
+            return 'LineFeed';
+        case 2 /* CarriageReturnLineFeed */:
+            return 'CarriageReturnLineFeed';
+        case 3 /* Implied */:
+            return 'Implied';
+        default:
+            return `Unknown Value!! (${type})`;
+    }
+}
+function getOperatorTypeString(type) {
+    switch (type) {
+        case 0 /* Add */:
+            return 'Add';
+        case 1 /* AddEqual */:
+            return 'AddEqual';
+        case 2 /* Assign */:
+            return 'Assign';
+        case 3 /* BitwiseAnd */:
+            return 'BitwiseAnd';
+        case 4 /* BitwiseAndEqual */:
+            return 'BitwiseAndEqual';
+        case 5 /* BitwiseInvert */:
+            return 'BitwiseInvert';
+        case 6 /* BitwiseOr */:
+            return 'BitwiseOr';
+        case 7 /* BitwiseOrEqual */:
+            return 'BitwiseOrEqual';
+        case 8 /* BitwiseXor */:
+            return 'BitwiseXor';
+        case 9 /* BitwiseXorEqual */:
+            return 'BitwiseXorEqual';
+        case 10 /* Divide */:
+            return 'Divide';
+        case 11 /* DivideEqual */:
+            return 'DivideEqual';
+        case 12 /* Equals */:
+            return 'Equals';
+        case 13 /* FloorDivide */:
+            return 'FloorDivide';
+        case 14 /* FloorDivideEqual */:
+            return 'FloorDivideEqual';
+        case 15 /* GreaterThan */:
+            return 'GreaterThan';
+        case 16 /* GreaterThanOrEqual */:
+            return 'GreaterThanOrEqual';
+        case 17 /* LeftShift */:
+            return 'LeftShift';
+        case 18 /* LeftShiftEqual */:
+            return 'LeftShiftEqual';
+        case 19 /* LessOrGreaterThan */:
+            return 'LessOrGreaterThan';
+        case 20 /* LessThan */:
+            return 'LessThan';
+        case 21 /* LessThanOrEqual */:
+            return 'LessThanOrEqual';
+        case 22 /* MatrixMultiply */:
+            return 'MatrixMultiply';
+        case 23 /* MatrixMultiplyEqual */:
+            return 'MatrixMultiplyEqual';
+        case 24 /* Mod */:
+            return 'Mod';
+        case 25 /* ModEqual */:
+            return 'ModEqual';
+        case 26 /* Multiply */:
+            return 'Multiply';
+        case 27 /* MultiplyEqual */:
+            return 'MultiplyEqual';
+        case 28 /* NotEquals */:
+            return 'NotEquals';
+        case 29 /* Power */:
+            return 'Power';
+        case 30 /* PowerEqual */:
+            return 'PowerEqual';
+        case 31 /* RightShift */:
+            return 'RightShift';
+        case 32 /* RightShiftEqual */:
+            return 'RightShiftEqual';
+        case 33 /* Subtract */:
+            return 'Subtract';
+        case 34 /* SubtractEqual */:
+            return 'SubtractEqual';
+        case 35 /* Walrus */:
+            return 'Walrus';
+        case 36 /* And */:
+            return 'And';
+        case 37 /* Or */:
+            return 'Or';
+        case 38 /* Not */:
+            return 'Not';
+        case 39 /* Is */:
+            return 'Is';
+        case 40 /* IsNot */:
+            return 'IsNot';
+        case 41 /* In */:
+            return 'In';
+        case 42 /* NotIn */:
+            return 'NotIn';
+        default:
+            return `Unknown Value!! (${type})`;
+    }
+}
+function getKeywordTypeString(type) {
+    switch (type) {
+        case 0 /* And */:
+            return 'And';
+        case 1 /* As */:
+            return 'As';
+        case 2 /* Assert */:
+            return 'Assert';
+        case 3 /* Async */:
+            return 'Async';
+        case 4 /* Await */:
+            return 'Await';
+        case 5 /* Break */:
+            return 'Break';
+        case 7 /* Class */:
+            return 'Class';
+        case 8 /* Continue */:
+            return 'Continue';
+        case 9 /* Debug */:
+            return 'Debug';
+        case 10 /* Def */:
+            return 'Def';
+        case 11 /* Del */:
+            return 'Del';
+        case 12 /* Elif */:
+            return 'Elif';
+        case 13 /* Else */:
+            return 'Else';
+        case 14 /* Except */:
+            return 'Except';
+        case 15 /* False */:
+            return 'False';
+        case 16 /* Finally */:
+            return 'Finally';
+        case 17 /* For */:
+            return 'For';
+        case 18 /* From */:
+            return 'From';
+        case 19 /* Global */:
+            return 'Global';
+        case 20 /* If */:
+            return 'If';
+        case 21 /* Import */:
+            return 'Import';
+        case 22 /* In */:
+            return 'In';
+        case 23 /* Is */:
+            return 'Is';
+        case 24 /* Lambda */:
+            return 'Lambda';
+        case 26 /* None */:
+            return 'None';
+        case 27 /* Nonlocal */:
+            return 'Nonlocal';
+        case 28 /* Not */:
+            return 'Not';
+        case 29 /* Or */:
+            return 'Or';
+        case 30 /* Pass */:
+            return 'Pass';
+        case 31 /* Raise */:
+            return 'Raise';
+        case 32 /* Return */:
+            return 'Return';
+        case 33 /* True */:
+            return 'True';
+        case 34 /* Try */:
+            return 'Try';
+        case 36 /* While */:
+            return 'While';
+        case 37 /* With */:
+            return 'With';
+        case 38 /* 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'],
+];
+function getStringTokenFlagsString(flags) {
+    return getFlagEnumString(StringTokenFlagsStrings, flags);
+}
+//# sourceMappingURL=dumpFileDebugInfoCommand.js.map