@zzzen/pyright-internal 1.2.0-dev.20261018 → 1.2.0-dev.20261108

package/dist/parser/parseTreeTokenReuse.js

@@ -0,0 +1,897 @@
+"use strict";
+/*
+ * parseTreeTokenReuse.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseTreeTokenCursor = void 0;
+class ParseTreeTokenCursor {
+    constructor(root) {
+        this._frames = [];
+        this._depth = -1;
+        this._offset = -1;
+        this._previousStart = -1;
+        this._root = root;
+    }
+    next(start, length, type) {
+        if (this._offset !== start) {
+            this._offset = start;
+            this._tokenAtOffset = undefined;
+            if (this._atOffset?.length) {
+                this._atOffset.length = 0;
+            }
+            let token = this._lookahead ?? this._nextToken();
+            while (token && token.start < start) {
+                token = this._nextToken();
+            }
+            if (token && token.start === start) {
+                const firstToken = token;
+                token = this._nextToken();
+                if (!token || token.start !== start) {
+                    this._tokenAtOffset = firstToken;
+                }
+                else {
+                    // Only same-position collisions need a buffer; most positions have zero or one candidate.
+                    const atOffset = (this._atOffset ?? (this._atOffset = []));
+                    atOffset.push(firstToken);
+                    do {
+                        atOffset.push(token);
+                        token = this._nextToken();
+                    } while (token && token.start === start);
+                }
+            }
+            this._lookahead = token;
+        }
+        const token = this._tokenAtOffset;
+        if (token && token.length === length && isTokenType(token, type)) {
+            this._tokenAtOffset = undefined;
+            return token;
+        }
+        const atOffset = this._atOffset;
+        if (!atOffset) {
+            return undefined;
+        }
+        for (let index = 0; index < atOffset.length; index++) {
+            const token = atOffset[index];
+            if (token.length === length && isTokenType(token, type)) {
+                atOffset[index] = atOffset[atOffset.length - 1];
+                atOffset.pop();
+                return token;
+            }
+        }
+        return undefined;
+    }
+    _nextToken() {
+        if (this._root) {
+            const root = this._root;
+            this._root = undefined;
+            this._enter(root);
+        }
+        while (this._depth >= 0) {
+            const frame = this._frames[this._depth];
+            let token;
+            if (frame.child && (!frame.token || frame.child.start < frame.token.start)) {
+                const child = frame.child;
+                this._advanceChild(frame);
+                switch (child.nodeType) {
+                    case 38 /* ParseNodeType.Name */:
+                    case 49 /* ParseNodeType.String */:
+                        token = child.d.token;
+                        break;
+                    case 40 /* ParseNodeType.Number */:
+                    case 14 /* ParseNodeType.Constant */:
+                    case 21 /* ParseNodeType.Ellipsis */:
+                    case 8 /* ParseNodeType.Break */:
+                    case 15 /* ParseNodeType.Continue */:
+                    case 42 /* ParseNodeType.Pass */:
+                        continue;
+                    default:
+                        this._enter(child);
+                        continue;
+                }
+            }
+            else if (frame.token) {
+                token = frame.token;
+                this._advanceToken(frame);
+            }
+            else {
+                frame.node = undefined;
+                frame.child = null;
+                frame.assignmentTarget = undefined;
+                frame.assignmentValue = undefined;
+                this._depth--;
+                continue;
+            }
+            if (token === this._previousToken ||
+                (token.length === 0 && (token.type === 7 /* TokenType.Identifier */ || token.type === 8 /* TokenType.Keyword */))) {
+                continue;
+            }
+            if (token.start < this._previousStart) {
+                throw new Error('Retained parse-tree tokens are not in source order');
+            }
+            this._previousToken = token;
+            this._previousStart = token.start;
+            return token;
+        }
+        return undefined;
+    }
+    _enter(node) {
+        const depth = ++this._depth;
+        let frame = this._frames[depth];
+        if (!frame) {
+            frame = {
+                node: undefined,
+                childIndex: 0,
+                tokenIndex: 0,
+                child: null,
+                token: null,
+                assignmentTarget: undefined,
+                assignmentValue: undefined,
+                fieldIndex: 0,
+                formatIndex: 0,
+            };
+            this._frames.push(frame);
+        }
+        frame.node = node;
+        frame.childIndex = 0;
+        frame.tokenIndex = 0;
+        frame.assignmentTarget = undefined;
+        frame.assignmentValue = undefined;
+        frame.fieldIndex = 0;
+        frame.formatIndex = 0;
+        if (node.nodeType === 3 /* ParseNodeType.Assignment */) {
+            let target = node;
+            while (target.d.rightExpr.nodeType === 3 /* ParseNodeType.Assignment */) {
+                target = target.d.rightExpr;
+            }
+            frame.assignmentTarget = target;
+            frame.assignmentValue = target.d.rightExpr;
+        }
+        this._updateChild(frame);
+        frame.token = getNodeToken(node, 0);
+        while (frame.token === undefined) {
+            frame.token = getNodeToken(node, ++frame.tokenIndex);
+        }
+    }
+    _getChild(frame) {
+        const node = frame.node;
+        if (node.nodeType === 3 /* ParseNodeType.Assignment */) {
+            if (frame.assignmentTarget) {
+                return frame.assignmentTarget.d.leftExpr;
+            }
+            return frame.childIndex === 1 ? frame.assignmentValue : null;
+        }
+        if (node.nodeType === 30 /* ParseNodeType.FormatString */) {
+            const field = node.d.fieldExprs[frame.fieldIndex];
+            const format = node.d.formatExprs[frame.formatIndex];
+            return field && (!format || field.start <= format.start) ? field : format ?? null;
+        }
+        return getChildAt(node, frame.childIndex);
+    }
+    _advanceChild(frame) {
+        const node = frame.node;
+        if (node.nodeType === 3 /* ParseNodeType.Assignment */ && frame.assignmentTarget) {
+            if (frame.assignmentTarget === node) {
+                frame.assignmentTarget = undefined;
+                frame.childIndex = 1;
+            }
+            else {
+                const parent = frame.assignmentTarget.parent;
+                if (parent?.nodeType !== 3 /* ParseNodeType.Assignment */ || parent.d.rightExpr !== frame.assignmentTarget) {
+                    throw new Error('Chained assignment has inconsistent parent links');
+                }
+                frame.assignmentTarget = parent;
+            }
+        }
+        else if (node.nodeType === 30 /* ParseNodeType.FormatString */) {
+            if (frame.child === node.d.fieldExprs[frame.fieldIndex]) {
+                frame.fieldIndex++;
+            }
+            else {
+                frame.formatIndex++;
+            }
+        }
+        else {
+            frame.childIndex++;
+        }
+        this._updateChild(frame);
+    }
+    _updateChild(frame) {
+        frame.child = this._getChild(frame);
+        while (frame.child === undefined) {
+            frame.childIndex++;
+            frame.child = this._getChild(frame);
+        }
+    }
+    _advanceToken(frame) {
+        frame.token = getNodeToken(frame.node, ++frame.tokenIndex);
+        while (frame.token === undefined) {
+            frame.token = getNodeToken(frame.node, ++frame.tokenIndex);
+        }
+    }
+}
+exports.ParseTreeTokenCursor = ParseTreeTokenCursor;
+function getNodeToken(node, index) {
+    switch (node.nodeType) {
+        case 38 /* ParseNodeType.Name */:
+        case 49 /* ParseNodeType.String */:
+            return index === 0 ? node.d.token : null;
+        case 7 /* ParseNodeType.BinaryOperation */:
+        case 55 /* ParseNodeType.UnaryOperation */:
+            return index === 0 ? node.d.operatorToken : null;
+        case 30 /* ParseNodeType.FormatString */:
+            return index === 0
+                ? node.d.token
+                : index <= node.d.middleTokens.length
+                    ? node.d.middleTokens[index - 1]
+                    : null;
+        case 22 /* ParseNodeType.If */:
+        case 57 /* ParseNodeType.While */:
+        case 53 /* ParseNodeType.Try */:
+        case 31 /* ParseNodeType.Function */:
+        case 10 /* ParseNodeType.Class */:
+        case 47 /* ParseNodeType.StatementList */:
+        case 77 /* ParseNodeType.TypeAlias */:
+        case 63 /* ParseNodeType.Match */:
+            return index === 0 ? node.d.firstToken : null;
+        case 29 /* ParseNodeType.For */:
+        case 58 /* ParseNodeType.With */:
+            return index === 0 ? node.d.asyncToken : index === 1 ? node.d.firstToken : null;
+        case 12 /* ParseNodeType.ComprehensionFor */:
+            return index === 0 ? node.d.asyncToken : null;
+        case 28 /* ParseNodeType.Except */:
+            return index === 0 ? node.d.exceptToken : null;
+        case 4 /* ParseNodeType.AssignmentExpression */:
+            return index === 0 ? node.d.walrusToken : null;
+        case 6 /* ParseNodeType.Await */:
+            return index === 0 ? node.d.awaitToken : null;
+        case 56 /* ParseNodeType.Unpack */:
+            return index === 0 ? node.d.starToken : null;
+        case 18 /* ParseNodeType.Dictionary */:
+            return index === 0 ? node.d.trailingCommaToken : null;
+        case 23 /* ParseNodeType.Import */:
+            return index === 0 ? node.d.lazyToken : null;
+        case 25 /* ParseNodeType.ImportFrom */:
+            return index === 0 ? node.d.lazyToken : index === 1 ? node.d.wildcardToken : null;
+        default:
+            return null;
+    }
+}
+function getChildAt(node, index) {
+    switch (node.nodeType) {
+        case 0 /* ParseNodeType.Error */: {
+            if (node.d.decorators && index < node.d.decorators.length)
+                return node.d.decorators[index];
+            index -= node.d.decorators?.length ?? 0;
+            if (index === 0)
+                return node.d.child;
+            index--;
+            return null;
+        }
+        case 1 /* ParseNodeType.Argument */: {
+            if (index === 0)
+                return node.d.name;
+            index--;
+            if (index === 0)
+                return node.d.valueExpr;
+            index--;
+            return null;
+        }
+        case 2 /* ParseNodeType.Assert */: {
+            if (index === 0)
+                return node.d.testExpr;
+            index--;
+            if (index === 0)
+                return node.d.exceptionExpr;
+            index--;
+            return null;
+        }
+        case 4 /* ParseNodeType.AssignmentExpression */: {
+            if (index === 0)
+                return node.d.name;
+            index--;
+            if (index === 0)
+                return node.d.rightExpr;
+            index--;
+            return null;
+        }
+        case 3 /* ParseNodeType.Assignment */: {
+            if (index === 0)
+                return node.d.leftExpr;
+            index--;
+            if (index === 0)
+                return node.d.rightExpr;
+            index--;
+            return null;
+        }
+        case 5 /* ParseNodeType.AugmentedAssignment */: {
+            if (index === 0)
+                return node.d.leftExpr;
+            index--;
+            if (index === 0)
+                return node.d.rightExpr;
+            index--;
+            return null;
+        }
+        case 6 /* ParseNodeType.Await */: {
+            if (index === 0)
+                return node.d.expr;
+            index--;
+            return null;
+        }
+        case 7 /* ParseNodeType.BinaryOperation */: {
+            if (index === 0)
+                return node.d.leftExpr;
+            index--;
+            if (index === 0)
+                return node.d.rightExpr;
+            index--;
+            return null;
+        }
+        case 8 /* ParseNodeType.Break */: {
+            return null;
+        }
+        case 9 /* ParseNodeType.Call */: {
+            if (index === 0)
+                return node.d.leftExpr;
+            index--;
+            if (index < node.d.args.length)
+                return node.d.args[index];
+            index -= node.d.args.length;
+            return null;
+        }
+        case 64 /* ParseNodeType.Case */: {
+            if (index === 0)
+                return node.d.pattern;
+            index--;
+            if (index === 0)
+                return node.d.guardExpr;
+            index--;
+            if (index === 0)
+                return node.d.suite;
+            index--;
+            return null;
+        }
+        case 10 /* ParseNodeType.Class */: {
+            if (index < node.d.decorators.length)
+                return node.d.decorators[index];
+            index -= node.d.decorators.length;
+            if (index === 0)
+                return node.d.name;
+            index--;
+            if (index === 0)
+                return node.d.typeParams;
+            index--;
+            if (index < node.d.arguments.length)
+                return node.d.arguments[index];
+            index -= node.d.arguments.length;
+            if (index === 0)
+                return node.d.suite;
+            index--;
+            return null;
+        }
+        case 11 /* ParseNodeType.Comprehension */: {
+            if (index === 0)
+                return node.d.expr;
+            index--;
+            if (index < node.d.forIfNodes.length)
+                return node.d.forIfNodes[index];
+            index -= node.d.forIfNodes.length;
+            return null;
+        }
+        case 12 /* ParseNodeType.ComprehensionFor */: {
+            if (index === 0)
+                return node.d.targetExpr;
+            index--;
+            if (index === 0)
+                return node.d.iterableExpr;
+            index--;
+            return null;
+        }
+        case 13 /* ParseNodeType.ComprehensionIf */: {
+            if (index === 0)
+                return node.d.testExpr;
+            index--;
+            return null;
+        }
+        case 14 /* ParseNodeType.Constant */: {
+            return null;
+        }
+        case 15 /* ParseNodeType.Continue */: {
+            return null;
+        }
+        case 16 /* ParseNodeType.Decorator */: {
+            if (index === 0)
+                return node.d.expr;
+            index--;
+            return null;
+        }
+        case 17 /* ParseNodeType.Del */: {
+            if (index < node.d.targets.length)
+                return node.d.targets[index];
+            index -= node.d.targets.length;
+            return null;
+        }
+        case 18 /* ParseNodeType.Dictionary */: {
+            if (index < node.d.items.length)
+                return node.d.items[index];
+            index -= node.d.items.length;
+            return null;
+        }
+        case 19 /* ParseNodeType.DictionaryExpandEntry */: {
+            if (index === 0)
+                return node.d.expr;
+            index--;
+            return null;
+        }
+        case 20 /* ParseNodeType.DictionaryKeyEntry */: {
+            if (index === 0)
+                return node.d.keyExpr;
+            index--;
+            if (index === 0)
+                return node.d.valueExpr;
+            index--;
+            return null;
+        }
+        case 21 /* ParseNodeType.Ellipsis */: {
+            return null;
+        }
+        case 22 /* ParseNodeType.If */: {
+            if (index === 0)
+                return node.d.testExpr;
+            index--;
+            if (index === 0)
+                return node.d.ifSuite;
+            index--;
+            if (index === 0)
+                return node.d.elseSuite;
+            index--;
+            return null;
+        }
+        case 23 /* ParseNodeType.Import */: {
+            if (index < node.d.list.length)
+                return node.d.list[index];
+            index -= node.d.list.length;
+            return null;
+        }
+        case 24 /* ParseNodeType.ImportAs */: {
+            if (index === 0)
+                return node.d.module;
+            index--;
+            if (index === 0)
+                return node.d.alias;
+            index--;
+            return null;
+        }
+        case 25 /* ParseNodeType.ImportFrom */: {
+            if (index === 0)
+                return node.d.module;
+            index--;
+            if (index < node.d.imports.length)
+                return node.d.imports[index];
+            index -= node.d.imports.length;
+            return null;
+        }
+        case 26 /* ParseNodeType.ImportFromAs */: {
+            if (index === 0)
+                return node.d.name;
+            index--;
+            if (index === 0)
+                return node.d.alias;
+            index--;
+            return null;
+        }
+        case 27 /* ParseNodeType.Index */: {
+            if (index === 0)
+                return node.d.leftExpr;
+            index--;
+            if (index < node.d.items.length)
+                return node.d.items[index];
+            index -= node.d.items.length;
+            return null;
+        }
+        case 28 /* ParseNodeType.Except */: {
+            if (index === 0)
+                return node.d.typeExpr;
+            index--;
+            if (index === 0)
+                return node.d.name;
+            index--;
+            if (index === 0)
+                return node.d.exceptSuite;
+            index--;
+            return null;
+        }
+        case 29 /* ParseNodeType.For */: {
+            if (index === 0)
+                return node.d.targetExpr;
+            index--;
+            if (index === 0)
+                return node.d.iterableExpr;
+            index--;
+            if (index === 0)
+                return node.d.forSuite;
+            index--;
+            if (index === 0)
+                return node.d.elseSuite;
+            index--;
+            return null;
+        }
+        case 30 /* ParseNodeType.FormatString */: {
+            if (index < node.d.fieldExprs.length)
+                return node.d.fieldExprs[index];
+            index -= node.d.fieldExprs.length;
+            if (node.d.formatExprs && index < node.d.formatExprs.length)
+                return node.d.formatExprs[index];
+            index -= node.d.formatExprs?.length ?? 0;
+            return null;
+        }
+        case 31 /* ParseNodeType.Function */: {
+            if (index < node.d.decorators.length)
+                return node.d.decorators[index];
+            index -= node.d.decorators.length;
+            if (index === 0)
+                return node.d.name;
+            index--;
+            if (index === 0)
+                return node.d.typeParams;
+            index--;
+            if (index < node.d.params.length)
+                return node.d.params[index];
+            index -= node.d.params.length;
+            if (index === 0)
+                return node.d.returnAnnotation;
+            index--;
+            if (index === 0)
+                return node.d.suite;
+            index--;
+            return null;
+        }
+        case 62 /* ParseNodeType.FunctionAnnotation */: {
+            if (index < node.d.paramAnnotations.length)
+                return node.d.paramAnnotations[index];
+            index -= node.d.paramAnnotations.length;
+            if (index === 0)
+                return node.d.returnAnnotation;
+            index--;
+            return null;
+        }
+        case 32 /* ParseNodeType.Global */: {
+            if (index < node.d.targets.length)
+                return node.d.targets[index];
+            index -= node.d.targets.length;
+            return null;
+        }
+        case 33 /* ParseNodeType.Lambda */: {
+            if (index < node.d.params.length)
+                return node.d.params[index];
+            index -= node.d.params.length;
+            if (index === 0)
+                return node.d.expr;
+            index--;
+            return null;
+        }
+        case 34 /* ParseNodeType.List */: {
+            if (index < node.d.items.length)
+                return node.d.items[index];
+            index -= node.d.items.length;
+            return null;
+        }
+        case 63 /* ParseNodeType.Match */: {
+            if (index === 0)
+                return node.d.expr;
+            index--;
+            if (index < node.d.cases.length)
+                return node.d.cases[index];
+            index -= node.d.cases.length;
+            return null;
+        }
+        case 35 /* ParseNodeType.MemberAccess */: {
+            if (index === 0)
+                return node.d.leftExpr;
+            index--;
+            if (index === 0)
+                return node.d.member;
+            index--;
+            return null;
+        }
+        case 37 /* ParseNodeType.ModuleName */: {
+            if (index < node.d.nameParts.length)
+                return node.d.nameParts[index];
+            index -= node.d.nameParts.length;
+            return null;
+        }
+        case 36 /* ParseNodeType.Module */: {
+            if (index < node.d.statements.length)
+                return node.d.statements[index];
+            index -= node.d.statements.length;
+            return null;
+        }
+        case 38 /* ParseNodeType.Name */: {
+            return null;
+        }
+        case 39 /* ParseNodeType.Nonlocal */: {
+            if (index < node.d.targets.length)
+                return node.d.targets[index];
+            index -= node.d.targets.length;
+            return null;
+        }
+        case 40 /* ParseNodeType.Number */: {
+            return null;
+        }
+        case 41 /* ParseNodeType.Parameter */: {
+            if (index === 0)
+                return node.d.name;
+            index--;
+            if (index === 0)
+                return node.d.annotation;
+            index--;
+            if (index === 0)
+                return node.d.defaultValue;
+            index--;
+            return null;
+        }
+        case 42 /* ParseNodeType.Pass */: {
+            return null;
+        }
+        case 66 /* ParseNodeType.PatternAs */: {
+            if (index < node.d.orPatterns.length)
+                return node.d.orPatterns[index];
+            index -= node.d.orPatterns.length;
+            if (index === 0)
+                return node.d.target;
+            index--;
+            return null;
+        }
+        case 68 /* ParseNodeType.PatternClass */: {
+            if (index === 0)
+                return node.d.className;
+            index--;
+            if (index < node.d.args.length)
+                return node.d.args[index];
+            index -= node.d.args.length;
+            return null;
+        }
+        case 74 /* ParseNodeType.PatternClassArgument */: {
+            if (index === 0)
+                return node.d.name;
+            index--;
+            if (index === 0)
+                return node.d.pattern;
+            index--;
+            return null;
+        }
+        case 69 /* ParseNodeType.PatternCapture */: {
+            if (index === 0)
+                return node.d.target;
+            index--;
+            return null;
+        }
+        case 67 /* ParseNodeType.PatternLiteral */: {
+            if (index === 0)
+                return node.d.expr;
+            index--;
+            return null;
+        }
+        case 72 /* ParseNodeType.PatternMappingExpandEntry */: {
+            if (index === 0)
+                return node.d.target;
+            index--;
+            return null;
+        }
+        case 71 /* ParseNodeType.PatternMappingKeyEntry */: {
+            if (index === 0)
+                return node.d.keyPattern;
+            index--;
+            if (index === 0)
+                return node.d.valuePattern;
+            index--;
+            return null;
+        }
+        case 70 /* ParseNodeType.PatternMapping */: {
+            if (index < node.d.entries.length)
+                return node.d.entries[index];
+            index -= node.d.entries.length;
+            return null;
+        }
+        case 65 /* ParseNodeType.PatternSequence */: {
+            if (index < node.d.entries.length)
+                return node.d.entries[index];
+            index -= node.d.entries.length;
+            return null;
+        }
+        case 73 /* ParseNodeType.PatternValue */: {
+            if (index === 0)
+                return node.d.expr;
+            index--;
+            return null;
+        }
+        case 43 /* ParseNodeType.Raise */: {
+            if (index === 0)
+                return node.d.expr;
+            index--;
+            if (index === 0)
+                return node.d.fromExpr;
+            index--;
+            return null;
+        }
+        case 44 /* ParseNodeType.Return */: {
+            if (index === 0)
+                return node.d.expr;
+            index--;
+            return null;
+        }
+        case 45 /* ParseNodeType.Set */: {
+            if (index < node.d.items.length)
+                return node.d.items[index];
+            index -= node.d.items.length;
+            return null;
+        }
+        case 46 /* ParseNodeType.Slice */: {
+            if (index === 0)
+                return node.d.startValue;
+            index--;
+            if (index === 0)
+                return node.d.endValue;
+            index--;
+            if (index === 0)
+                return node.d.stepValue;
+            index--;
+            return null;
+        }
+        case 47 /* ParseNodeType.StatementList */: {
+            if (index < node.d.statements.length)
+                return node.d.statements[index];
+            index -= node.d.statements.length;
+            return null;
+        }
+        case 48 /* ParseNodeType.StringList */: {
+            if (index < node.d.strings.length)
+                return node.d.strings[index];
+            index -= node.d.strings.length;
+            return null;
+        }
+        case 49 /* ParseNodeType.String */: {
+            return null;
+        }
+        case 50 /* ParseNodeType.Suite */: {
+            if (index < node.d.statements.length)
+                return node.d.statements[index];
+            index -= node.d.statements.length;
+            return null;
+        }
+        case 51 /* ParseNodeType.Ternary */: {
+            if (index === 0)
+                return node.d.ifExpr;
+            index--;
+            if (index === 0)
+                return node.d.testExpr;
+            index--;
+            if (index === 0)
+                return node.d.elseExpr;
+            index--;
+            return null;
+        }
+        case 52 /* ParseNodeType.Tuple */: {
+            if (index < node.d.items.length)
+                return node.d.items[index];
+            index -= node.d.items.length;
+            return null;
+        }
+        case 53 /* ParseNodeType.Try */: {
+            if (index === 0)
+                return node.d.trySuite;
+            index--;
+            if (index < node.d.exceptClauses.length)
+                return node.d.exceptClauses[index];
+            index -= node.d.exceptClauses.length;
+            if (index === 0)
+                return node.d.elseSuite;
+            index--;
+            if (index === 0)
+                return node.d.finallySuite;
+            index--;
+            return null;
+        }
+        case 77 /* ParseNodeType.TypeAlias */: {
+            if (index === 0)
+                return node.d.name;
+            index--;
+            if (index === 0)
+                return node.d.typeParams;
+            index--;
+            if (index === 0)
+                return node.d.expr;
+            index--;
+            return null;
+        }
+        case 54 /* ParseNodeType.TypeAnnotation */: {
+            if (index === 0)
+                return node.d.valueExpr;
+            index--;
+            if (index === 0)
+                return node.d.annotation;
+            index--;
+            return null;
+        }
+        case 75 /* ParseNodeType.TypeParameter */: {
+            if (index === 0)
+                return node.d.name;
+            index--;
+            if (index === 0)
+                return node.d.boundExpr;
+            index--;
+            if (index === 0)
+                return node.d.defaultExpr;
+            index--;
+            return null;
+        }
+        case 76 /* ParseNodeType.TypeParameterList */: {
+            if (index < node.d.params.length)
+                return node.d.params[index];
+            index -= node.d.params.length;
+            return null;
+        }
+        case 55 /* ParseNodeType.UnaryOperation */: {
+            if (index === 0)
+                return node.d.expr;
+            index--;
+            return null;
+        }
+        case 56 /* ParseNodeType.Unpack */: {
+            if (index === 0)
+                return node.d.expr;
+            index--;
+            return null;
+        }
+        case 57 /* ParseNodeType.While */: {
+            if (index === 0)
+                return node.d.testExpr;
+            index--;
+            if (index === 0)
+                return node.d.whileSuite;
+            index--;
+            if (index === 0)
+                return node.d.elseSuite;
+            index--;
+            return null;
+        }
+        case 58 /* ParseNodeType.With */: {
+            if (index < node.d.withItems.length)
+                return node.d.withItems[index];
+            index -= node.d.withItems.length;
+            if (index === 0)
+                return node.d.suite;
+            index--;
+            return null;
+        }
+        case 59 /* ParseNodeType.WithItem */: {
+            if (index === 0)
+                return node.d.expr;
+            index--;
+            if (index === 0)
+                return node.d.target;
+            index--;
+            return null;
+        }
+        case 60 /* ParseNodeType.Yield */: {
+            if (index === 0)
+                return node.d.expr;
+            index--;
+            return null;
+        }
+        case 61 /* ParseNodeType.YieldFrom */: {
+            if (index === 0)
+                return node.d.expr;
+            index--;
+            return null;
+        }
+        default:
+            throw new Error('Unsupported parse node in retained-token cursor');
+    }
+}
+function isTokenType(token, type) {
+    return token.type === type;
+}
+//# sourceMappingURL=parseTreeTokenReuse.js.map