@zzzen/pyright-internal 1.1.254

package/dist/analyzer/parseTreeUtils.js

@@ -0,0 +1,1753 @@
+"use strict";
+/*
+ * parseTreeUtils.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * Utility routines for traversing a parse tree.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypeAnnotationForParameter = exports.isFunctionSuiteEmpty = exports.getFileInfoFromNode = exports.getModuleNode = exports.isWriteAccess = exports.printParseNodeType = exports.getTokenOverlapping = exports.getTokenAt = exports.getCallNodeAndActiveParameterIndex = exports.getEnclosingParameter = exports.CallNodeWalker = exports.NameNodeWalker = exports.isAssignmentToDefaultsFollowingNamedTuple = exports.isDocString = exports.getDocString = exports.isWithinAssertExpression = exports.isWithinTryBlock = exports.isWithinLoop = exports.isWithinAnnotationComment = exports.isWithinTypeAnnotation = exports.isWithinDefaultParamInitializer = exports.isPartialMatchingExpression = exports.isMatchingExpression = exports.isSuiteEmpty = exports.isNodeContainedWithinNodeType = exports.getParentNodeOfType = exports.isNodeContainedWithin = exports.isClassVarAllowedForAssignmentTarget = exports.isFinalAllowedForAssignmentTarget = exports.getTypeAnnotationNode = exports.getExecutionScopeNode = exports.getTypeVarScopeNode = exports.getEvaluationScopeNode = exports.getEvaluationNodeForAssignmentExpression = exports.getEnclosingSuiteOrModule = exports.getEnclosingClassOrFunction = exports.getEnclosingLambda = exports.getEnclosingFunction = exports.getEnclosingClassOrModule = exports.getEnclosingModule = exports.getEnclosingClass = exports.getEnclosingSuite = exports.printOperator = exports.printExpression = exports.printArgument = exports.getTypeSourceId = exports.getClassFullName = exports.findNodeByOffset = exports.findNodeByPosition = exports.getNodeDepth = void 0;
+exports.isUnannotatedFunction = exports.getFullStatementRange = exports.getStringValueRange = exports.getStringNodeValueRange = exports.isLastNameOfDottedName = exports.isFirstNameOfDottedName = exports.getFirstNameOfDottedName = exports.getDottedName = exports.getDottedNameWithGivenNodeAsLastName = exports.getFirstAncestorOrSelf = exports.getFirstAncestorOrSelfOfKind = exports.isLastNameOfModuleName = exports.isFromImportAlias = exports.isFromImportName = exports.isFromImportModuleName = exports.isImportAlias = exports.isImportModuleName = void 0;
+const AnalyzerNodeInfo = __importStar(require("../analyzer/analyzerNodeInfo"));
+const debug_1 = require("../common/debug");
+const positionUtils_1 = require("../common/positionUtils");
+const textRange_1 = require("../common/textRange");
+const parseNodes_1 = require("../parser/parseNodes");
+const analyzerNodeInfo_1 = require("./analyzerNodeInfo");
+const parseTreeWalker_1 = require("./parseTreeWalker");
+// Returns the depth of the node as measured from the root
+// of the parse tree.
+function getNodeDepth(node) {
+    let depth = 0;
+    let curNode = node;
+    while (curNode) {
+        depth++;
+        curNode = curNode.parent;
+    }
+    return depth;
+}
+exports.getNodeDepth = getNodeDepth;
+// Returns the deepest node that contains the specified position.
+function findNodeByPosition(node, position, lines) {
+    const offset = (0, positionUtils_1.convertPositionToOffset)(position, lines);
+    if (offset === undefined) {
+        return undefined;
+    }
+    return findNodeByOffset(node, offset);
+}
+exports.findNodeByPosition = findNodeByPosition;
+// Returns the deepest node that contains the specified offset.
+function findNodeByOffset(node, offset) {
+    if (offset < node.start || offset > textRange_1.TextRange.getEnd(node)) {
+        return undefined;
+    }
+    const parseTreeWalker = new parseTreeWalker_1.ParseTreeWalker();
+    // The range is found within this node. See if we can localize it
+    // further by checking its children.
+    const children = parseTreeWalker.visitNode(node);
+    for (const child of children) {
+        if (child) {
+            const containingChild = findNodeByOffset(child, offset);
+            if (containingChild) {
+                // For augmented assignments, prefer the dest expression, which is a clone
+                // of the left expression but is used to hold the type of the operation result.
+                if (node.nodeType === 5 /* AugmentedAssignment */ && containingChild === node.leftExpression) {
+                    return node.destExpression;
+                }
+                return containingChild;
+            }
+        }
+    }
+    return node;
+}
+exports.findNodeByOffset = findNodeByOffset;
+function getClassFullName(classNode, moduleName, className) {
+    const nameParts = [className];
+    let curNode = classNode;
+    // Walk the parse tree looking for classes.
+    while (curNode) {
+        curNode = getEnclosingClass(curNode);
+        if (curNode) {
+            nameParts.push(curNode.name.value);
+        }
+    }
+    nameParts.push(moduleName);
+    return nameParts.reverse().join('.');
+}
+exports.getClassFullName = getClassFullName;
+// Create an ID that is based on the location within the file.
+// This allows us to disambiguate between different types that
+// don't have unique names (those that are not created with class
+// declarations).
+function getTypeSourceId(node) {
+    return node.start;
+}
+exports.getTypeSourceId = getTypeSourceId;
+function printArgument(node, flags) {
+    let argStr = '';
+    if (node.argumentCategory === 1 /* UnpackedList */) {
+        argStr = '*';
+    }
+    else if (node.argumentCategory === 2 /* UnpackedDictionary */) {
+        argStr = '**';
+    }
+    if (node.name) {
+        argStr += node.name.value + '=';
+    }
+    argStr += printExpression(node.valueExpression, flags);
+    return argStr;
+}
+exports.printArgument = printArgument;
+function printExpression(node, flags = 0 /* None */) {
+    switch (node.nodeType) {
+        case 38 /* Name */: {
+            return node.value;
+        }
+        case 35 /* MemberAccess */: {
+            return printExpression(node.leftExpression, flags) + '.' + node.memberName.value;
+        }
+        case 9 /* Call */: {
+            return (printExpression(node.leftExpression, flags) +
+                '(' +
+                node.arguments.map((arg) => printArgument(arg, flags)).join(', ') +
+                ')');
+        }
+        case 24 /* Index */: {
+            return (printExpression(node.baseExpression, flags) +
+                '[' +
+                node.items.map((item) => printArgument(item, flags)).join(', ') +
+                (node.trailingComma ? ',' : '') +
+                ']');
+        }
+        case 55 /* UnaryOperation */: {
+            return printOperator(node.operator) + printExpression(node.expression, flags);
+        }
+        case 7 /* BinaryOperation */: {
+            const exprStr = printExpression(node.leftExpression, flags) +
+                ' ' +
+                printOperator(node.operator) +
+                ' ' +
+                printExpression(node.rightExpression, flags);
+            return node.parenthesized ? `(${exprStr})` : exprStr;
+        }
+        case 40 /* Number */: {
+            let value = node.value.toString();
+            // If it's stored as a bigint, strip off the "n".
+            if (value.endsWith('n')) {
+                value = value.substring(0, value.length - 1);
+            }
+            if (node.isImaginary) {
+                value += 'j';
+            }
+            return value;
+        }
+        case 48 /* StringList */: {
+            if (flags & 1 /* ForwardDeclarations */ && node.typeAnnotation) {
+                return printExpression(node.typeAnnotation, flags);
+            }
+            else {
+                return node.strings
+                    .map((str) => {
+                    return printExpression(str, flags);
+                })
+                    .join(' ');
+            }
+        }
+        case 49 /* String */: {
+            let exprString = '';
+            if (node.token.flags & 8 /* Raw */) {
+                exprString += 'r';
+            }
+            if (node.token.flags & 16 /* Unicode */) {
+                exprString += 'u';
+            }
+            if (node.token.flags & 32 /* Bytes */) {
+                exprString += 'b';
+            }
+            if (node.token.flags & 64 /* Format */) {
+                exprString += 'f';
+            }
+            let escapedString = node.token.escapedValue;
+            if ((flags & 2 /* DoNotLimitStringLength */) === 0) {
+                const maxStringLength = 32;
+                escapedString = escapedString.substring(0, maxStringLength);
+            }
+            if (node.token.flags & 4 /* Triplicate */) {
+                if (node.token.flags & 1 /* SingleQuote */) {
+                    exprString += `'''${escapedString}'''`;
+                }
+                else {
+                    exprString += `"""${escapedString}"""`;
+                }
+            }
+            else {
+                if (node.token.flags & 1 /* SingleQuote */) {
+                    exprString += `'${escapedString}'`;
+                }
+                else {
+                    exprString += `"${escapedString}"`;
+                }
+            }
+            return exprString;
+        }
+        case 3 /* Assignment */: {
+            return printExpression(node.leftExpression, flags) + ' = ' + printExpression(node.rightExpression, flags);
+        }
+        case 4 /* AssignmentExpression */: {
+            return printExpression(node.name, flags) + ' := ' + printExpression(node.rightExpression, flags);
+        }
+        case 54 /* TypeAnnotation */: {
+            return printExpression(node.valueExpression, flags) + ': ' + printExpression(node.typeAnnotation, flags);
+        }
+        case 5 /* AugmentedAssignment */: {
+            return (printExpression(node.leftExpression, flags) +
+                ' ' +
+                printOperator(node.operator) +
+                ' ' +
+                printExpression(node.rightExpression, flags));
+        }
+        case 6 /* Await */: {
+            return 'await ' + printExpression(node.expression, flags);
+        }
+        case 51 /* Ternary */: {
+            return (printExpression(node.ifExpression, flags) +
+                ' if ' +
+                printExpression(node.testExpression, flags) +
+                ' else ' +
+                printExpression(node.elseExpression, flags));
+        }
+        case 31 /* List */: {
+            const expressions = node.entries.map((expr) => {
+                return printExpression(expr, flags);
+            });
+            return `[${expressions.join(', ')}]`;
+        }
+        case 56 /* Unpack */: {
+            return '*' + printExpression(node.expression, flags);
+        }
+        case 52 /* Tuple */: {
+            const expressions = node.expressions.map((expr) => {
+                return printExpression(expr, flags);
+            });
+            if (expressions.length === 1) {
+                return `(${expressions[0]}, )`;
+            }
+            return `(${expressions.join(', ')})`;
+        }
+        case 60 /* Yield */: {
+            if (node.expression) {
+                return 'yield ' + printExpression(node.expression, flags);
+            }
+            else {
+                return 'yield';
+            }
+        }
+        case 61 /* YieldFrom */: {
+            return 'yield from ' + printExpression(node.expression, flags);
+        }
+        case 18 /* Ellipsis */: {
+            return '...';
+        }
+        case 32 /* ListComprehension */: {
+            let listStr = '<ListExpression>';
+            if ((0, parseNodes_1.isExpressionNode)(node.expression)) {
+                listStr = printExpression(node.expression, flags);
+            }
+            else if (node.expression.nodeType === 17 /* DictionaryKeyEntry */) {
+                const keyStr = printExpression(node.expression.keyExpression, flags);
+                const valueStr = printExpression(node.expression.valueExpression, flags);
+                listStr = `${keyStr}: ${valueStr}`;
+            }
+            listStr =
+                listStr +
+                    ' ' +
+                    node.forIfNodes
+                        .map((expr) => {
+                        if (expr.nodeType === 33 /* ListComprehensionFor */) {
+                            return (`${expr.isAsync ? 'async ' : ''}for ` +
+                                printExpression(expr.targetExpression, flags) +
+                                ` in ${printExpression(expr.iterableExpression, flags)}`);
+                        }
+                        else {
+                            return `if ${printExpression(expr.testExpression, flags)}`;
+                        }
+                    })
+                        .join(' ');
+            return node.isParenthesized ? `(${listStr}})` : listStr;
+        }
+        case 46 /* Slice */: {
+            let result = '';
+            if (node.startValue) {
+                result += printExpression(node.startValue, flags);
+            }
+            if (node.endValue) {
+                result += ': ' + printExpression(node.endValue, flags);
+            }
+            if (node.stepValue) {
+                result += ': ' + printExpression(node.stepValue, flags);
+            }
+            return result;
+        }
+        case 30 /* Lambda */: {
+            return ('lambda ' +
+                node.parameters
+                    .map((param) => {
+                    let paramStr = '';
+                    if (param.category === 1 /* VarArgList */) {
+                        paramStr += '*';
+                    }
+                    else if (param.category === 2 /* VarArgDictionary */) {
+                        paramStr += '**';
+                    }
+                    if (param.name) {
+                        paramStr += param.name.value;
+                    }
+                    else if (param.category === 0 /* Simple */) {
+                        paramStr += '/';
+                    }
+                    if (param.defaultValue) {
+                        paramStr += ' = ' + printExpression(param.defaultValue, flags);
+                    }
+                    return paramStr;
+                })
+                    .join(', ') +
+                ': ' +
+                printExpression(node.expression, flags));
+        }
+        case 11 /* Constant */: {
+            if (node.constType === 33 /* True */) {
+                return 'True';
+            }
+            else if (node.constType === 15 /* False */) {
+                return 'False';
+            }
+            else if (node.constType === 9 /* Debug */) {
+                return '__debug__';
+            }
+            else if (node.constType === 26 /* None */) {
+                return 'None';
+            }
+            break;
+        }
+        case 15 /* Dictionary */: {
+            const dictContents = `${node.entries.map((entry) => {
+                if (entry.nodeType === 17 /* DictionaryKeyEntry */) {
+                    return (`${printExpression(entry.keyExpression, flags)}: ` +
+                        `${printExpression(entry.valueExpression, flags)}`);
+                }
+                else if (entry.nodeType === 16 /* DictionaryExpandEntry */) {
+                    return `**${printExpression(entry.expandExpression, flags)}`;
+                }
+                else {
+                    return printExpression(entry, flags);
+                }
+            })}`;
+            if (dictContents) {
+                return `{ ${dictContents} }`;
+            }
+            return '{}';
+        }
+        case 45 /* Set */: {
+            return node.entries.map((entry) => printExpression(entry, flags)).join(', ');
+        }
+    }
+    return '<Expression>';
+}
+exports.printExpression = printExpression;
+function printOperator(operator) {
+    const operatorMap = {
+        [0 /* Add */]: '+',
+        [1 /* AddEqual */]: '+=',
+        [2 /* Assign */]: '=',
+        [3 /* BitwiseAnd */]: '&',
+        [4 /* BitwiseAndEqual */]: '&=',
+        [5 /* BitwiseInvert */]: '~',
+        [6 /* BitwiseOr */]: '|',
+        [7 /* BitwiseOrEqual */]: '|=',
+        [8 /* BitwiseXor */]: '^',
+        [9 /* BitwiseXorEqual */]: '^=',
+        [10 /* Divide */]: '/',
+        [11 /* DivideEqual */]: '/=',
+        [12 /* Equals */]: '==',
+        [13 /* FloorDivide */]: '//',
+        [14 /* FloorDivideEqual */]: '//=',
+        [15 /* GreaterThan */]: '>',
+        [16 /* GreaterThanOrEqual */]: '>=',
+        [17 /* LeftShift */]: '<<',
+        [18 /* LeftShiftEqual */]: '<<=',
+        [19 /* LessOrGreaterThan */]: '<>',
+        [20 /* LessThan */]: '<',
+        [21 /* LessThanOrEqual */]: '<=',
+        [22 /* MatrixMultiply */]: '@',
+        [23 /* MatrixMultiplyEqual */]: '@=',
+        [24 /* Mod */]: '%',
+        [25 /* ModEqual */]: '%=',
+        [26 /* Multiply */]: '*',
+        [27 /* MultiplyEqual */]: '*=',
+        [28 /* NotEquals */]: '!=',
+        [29 /* Power */]: '**',
+        [30 /* PowerEqual */]: '**=',
+        [31 /* RightShift */]: '>>',
+        [32 /* RightShiftEqual */]: '>>=',
+        [33 /* Subtract */]: '-',
+        [34 /* SubtractEqual */]: '-=',
+        [36 /* And */]: 'and',
+        [37 /* Or */]: 'or',
+        [38 /* Not */]: 'not',
+        [39 /* Is */]: 'is',
+        [40 /* IsNot */]: 'is not',
+        [41 /* In */]: 'in',
+        [42 /* NotIn */]: 'not in',
+    };
+    if (operatorMap[operator]) {
+        return operatorMap[operator];
+    }
+    return 'unknown';
+}
+exports.printOperator = printOperator;
+function getEnclosingSuite(node) {
+    let curNode = node.parent;
+    while (curNode) {
+        if (curNode.nodeType === 50 /* Suite */) {
+            return curNode;
+        }
+        curNode = curNode.parent;
+    }
+    return undefined;
+}
+exports.getEnclosingSuite = getEnclosingSuite;
+function getEnclosingClass(node, stopAtFunction = false) {
+    let curNode = node.parent;
+    while (curNode) {
+        if (curNode.nodeType === 10 /* Class */) {
+            return curNode;
+        }
+        if (curNode.nodeType === 36 /* Module */) {
+            return undefined;
+        }
+        if (curNode.nodeType === 28 /* Function */) {
+            if (stopAtFunction) {
+                return undefined;
+            }
+        }
+        curNode = curNode.parent;
+    }
+    return undefined;
+}
+exports.getEnclosingClass = getEnclosingClass;
+function getEnclosingModule(node) {
+    let curNode = node.parent;
+    while (curNode) {
+        if (curNode.nodeType === 36 /* Module */) {
+            return curNode;
+        }
+        curNode = curNode.parent;
+    }
+    (0, debug_1.fail)('Module node not found');
+    return undefined;
+}
+exports.getEnclosingModule = getEnclosingModule;
+function getEnclosingClassOrModule(node, stopAtFunction = false) {
+    let curNode = node.parent;
+    while (curNode) {
+        if (curNode.nodeType === 10 /* Class */) {
+            return curNode;
+        }
+        if (curNode.nodeType === 36 /* Module */) {
+            return curNode;
+        }
+        if (curNode.nodeType === 28 /* Function */) {
+            if (stopAtFunction) {
+                return undefined;
+            }
+        }
+        curNode = curNode.parent;
+    }
+    return undefined;
+}
+exports.getEnclosingClassOrModule = getEnclosingClassOrModule;
+function getEnclosingFunction(node) {
+    let curNode = node.parent;
+    let prevNode;
+    while (curNode) {
+        if (curNode.nodeType === 28 /* Function */) {
+            // Don't treat a decorator as being "enclosed" in the function.
+            if (!curNode.decorators.some((decorator) => decorator === prevNode)) {
+                return curNode;
+            }
+        }
+        if (curNode.nodeType === 10 /* Class */) {
+            return undefined;
+        }
+        prevNode = curNode;
+        curNode = curNode.parent;
+    }
+    return undefined;
+}
+exports.getEnclosingFunction = getEnclosingFunction;
+function getEnclosingLambda(node) {
+    let curNode = node.parent;
+    while (curNode) {
+        if (curNode.nodeType === 30 /* Lambda */) {
+            return curNode;
+        }
+        if (curNode.nodeType === 50 /* Suite */) {
+            return undefined;
+        }
+        curNode = curNode.parent;
+    }
+    return undefined;
+}
+exports.getEnclosingLambda = getEnclosingLambda;
+function getEnclosingClassOrFunction(node) {
+    let curNode = node.parent;
+    while (curNode) {
+        if (curNode.nodeType === 28 /* Function */) {
+            return curNode;
+        }
+        if (curNode.nodeType === 10 /* Class */) {
+            return curNode;
+        }
+        curNode = curNode.parent;
+    }
+    return undefined;
+}
+exports.getEnclosingClassOrFunction = getEnclosingClassOrFunction;
+function getEnclosingSuiteOrModule(node, stopAtFunction = false, stopAtLambda = true) {
+    let curNode = node.parent;
+    while (curNode) {
+        if (curNode.nodeType === 50 /* Suite */) {
+            return curNode;
+        }
+        if (curNode.nodeType === 36 /* Module */) {
+            return curNode;
+        }
+        if (curNode.nodeType === 30 /* Lambda */) {
+            if (stopAtLambda) {
+                return undefined;
+            }
+        }
+        if (curNode.nodeType === 28 /* Function */) {
+            if (stopAtFunction) {
+                return undefined;
+            }
+        }
+        curNode = curNode.parent;
+    }
+    return undefined;
+}
+exports.getEnclosingSuiteOrModule = getEnclosingSuiteOrModule;
+function getEvaluationNodeForAssignmentExpression(node) {
+    // PEP 572 indicates that the evaluation node for an assignment expression
+    // target within a list comprehension is contained within a lambda,
+    // function or module, but not a class.
+    let sawListComprehension = false;
+    let curNode = getEvaluationScopeNode(node);
+    while (curNode !== undefined) {
+        switch (curNode.nodeType) {
+            case 28 /* Function */:
+            case 30 /* Lambda */:
+            case 36 /* Module */:
+                return curNode;
+            case 10 /* Class */:
+                return sawListComprehension ? undefined : curNode;
+            case 32 /* ListComprehension */:
+                sawListComprehension = true;
+                curNode = getEvaluationScopeNode(curNode.parent);
+                break;
+            default:
+                return undefined;
+        }
+    }
+    return undefined;
+}
+exports.getEvaluationNodeForAssignmentExpression = getEvaluationNodeForAssignmentExpression;
+// Returns the parse node corresponding to the scope that is used to evaluate
+// a symbol referenced in the specified node.
+function getEvaluationScopeNode(node) {
+    let prevNode;
+    let prevPrevNode;
+    let curNode = node;
+    let isParamNameNode = false;
+    while (curNode) {
+        if (curNode.nodeType === 41 /* Parameter */ && prevNode === curNode.name) {
+            // Note that we passed through a parameter name node.
+            isParamNameNode = true;
+        }
+        // We found a scope associated with this node. In most cases,
+        // we'll return this scope, but in a few cases we need to return
+        // the enclosing scope instead.
+        switch (curNode.nodeType) {
+            case 28 /* Function */: {
+                if (curNode.parameters.some((param) => param === prevNode)) {
+                    if (isParamNameNode) {
+                        if ((0, analyzerNodeInfo_1.getScope)(curNode) !== undefined) {
+                            return curNode;
+                        }
+                    }
+                }
+                else if (prevNode === curNode.suite) {
+                    if ((0, analyzerNodeInfo_1.getScope)(curNode) !== undefined) {
+                        return curNode;
+                    }
+                }
+                break;
+            }
+            case 30 /* Lambda */: {
+                if (curNode.parameters.some((param) => param === prevNode)) {
+                    if (isParamNameNode) {
+                        if ((0, analyzerNodeInfo_1.getScope)(curNode) !== undefined) {
+                            return curNode;
+                        }
+                    }
+                }
+                else if (!prevNode || prevNode === curNode.expression) {
+                    if ((0, analyzerNodeInfo_1.getScope)(curNode) !== undefined) {
+                        return curNode;
+                    }
+                }
+                break;
+            }
+            case 10 /* Class */: {
+                if (prevNode === curNode.suite) {
+                    if ((0, analyzerNodeInfo_1.getScope)(curNode) !== undefined) {
+                        return curNode;
+                    }
+                }
+                break;
+            }
+            case 32 /* ListComprehension */: {
+                if ((0, analyzerNodeInfo_1.getScope)(curNode) !== undefined) {
+                    // The iterable expression of the first subnode of a list comprehension
+                    // is evaluated within the scope of its parent.
+                    const isFirstIterableExpr = prevNode === curNode.forIfNodes[0] &&
+                        curNode.forIfNodes[0].nodeType === 33 /* ListComprehensionFor */ &&
+                        curNode.forIfNodes[0].iterableExpression === prevPrevNode;
+                    if (!isFirstIterableExpr) {
+                        return curNode;
+                    }
+                }
+                break;
+            }
+            case 36 /* Module */: {
+                if ((0, analyzerNodeInfo_1.getScope)(curNode) !== undefined) {
+                    return curNode;
+                }
+                break;
+            }
+        }
+        prevPrevNode = prevNode;
+        prevNode = curNode;
+        curNode = curNode.parent;
+    }
+    (0, debug_1.fail)('Did not find evaluation scope');
+    return undefined;
+}
+exports.getEvaluationScopeNode = getEvaluationScopeNode;
+// Returns the parse node corresponding to the function or class that
+// contains the specified typeVar reference.
+function getTypeVarScopeNode(node, allowInFunctionSignature = false) {
+    let prevNode;
+    let curNode = node;
+    while (curNode) {
+        switch (curNode.nodeType) {
+            case 28 /* Function */: {
+                if (prevNode === curNode.suite || allowInFunctionSignature) {
+                    if (!curNode.decorators.some((decorator) => decorator === prevNode)) {
+                        return curNode;
+                    }
+                }
+                break;
+            }
+            case 10 /* Class */: {
+                if (prevNode === curNode.suite) {
+                    if (!curNode.decorators.some((decorator) => decorator === prevNode)) {
+                        return curNode;
+                    }
+                }
+                break;
+            }
+        }
+        prevNode = curNode;
+        curNode = curNode.parent;
+    }
+    return undefined;
+}
+exports.getTypeVarScopeNode = getTypeVarScopeNode;
+// Returns the parse node corresponding to the scope that is used
+// for executing the code referenced in the specified node.
+function getExecutionScopeNode(node) {
+    let evaluationScope = getEvaluationScopeNode(node);
+    // Classes are not considered execution scope because they are executed
+    // within the context of their containing module or function. Likewise, list
+    // comprehensions are executed within their container.
+    while (evaluationScope.nodeType === 10 /* Class */ ||
+        evaluationScope.nodeType === 32 /* ListComprehension */) {
+        evaluationScope = getEvaluationScopeNode(evaluationScope.parent);
+    }
+    return evaluationScope;
+}
+exports.getExecutionScopeNode = getExecutionScopeNode;
+// Given a node within a type annotation expression, returns the type annotation
+// node that contains it (if applicable).
+function getTypeAnnotationNode(node) {
+    let prevNode = node;
+    let curNode = node.parent;
+    while (curNode) {
+        if (curNode.nodeType === 54 /* TypeAnnotation */) {
+            if (curNode.typeAnnotation === prevNode) {
+                return curNode;
+            }
+            break;
+        }
+        prevNode = curNode;
+        curNode = curNode.parent;
+    }
+    return undefined;
+}
+exports.getTypeAnnotationNode = getTypeAnnotationNode;
+// PEP 591 spells out certain limited cases where an assignment target
+// can be annotated with a "Final" annotation. This function determines
+// whether Final is allowed for the specified node.
+function isFinalAllowedForAssignmentTarget(targetNode) {
+    // Simple names always support Final.
+    if (targetNode.nodeType === 38 /* Name */) {
+        return true;
+    }
+    // Member access expressions like "self.x" are permitted only
+    // within __init__ methods.
+    if (targetNode.nodeType === 35 /* MemberAccess */) {
+        if (targetNode.leftExpression.nodeType !== 38 /* Name */) {
+            return false;
+        }
+        const classNode = getEnclosingClass(targetNode);
+        if (!classNode) {
+            return false;
+        }
+        const methodNode = getEnclosingFunction(targetNode);
+        if (!methodNode) {
+            return false;
+        }
+        if (methodNode.name.value !== '__init__') {
+            return false;
+        }
+        return true;
+    }
+    return false;
+}
+exports.isFinalAllowedForAssignmentTarget = isFinalAllowedForAssignmentTarget;
+function isClassVarAllowedForAssignmentTarget(targetNode) {
+    const classNode = getEnclosingClass(targetNode, /* stopAtFunction */ true);
+    if (!classNode) {
+        return false;
+    }
+    return true;
+}
+exports.isClassVarAllowedForAssignmentTarget = isClassVarAllowedForAssignmentTarget;
+function isNodeContainedWithin(node, potentialContainer) {
+    let curNode = node;
+    while (curNode) {
+        if (curNode === potentialContainer) {
+            return true;
+        }
+        curNode = curNode.parent;
+    }
+    return false;
+}
+exports.isNodeContainedWithin = isNodeContainedWithin;
+function getParentNodeOfType(node, containerType) {
+    let curNode = node;
+    while (curNode) {
+        if (curNode.nodeType === containerType) {
+            return curNode;
+        }
+        curNode = curNode.parent;
+    }
+    return undefined;
+}
+exports.getParentNodeOfType = getParentNodeOfType;
+function isNodeContainedWithinNodeType(node, containerType) {
+    return getParentNodeOfType(node, containerType) !== undefined;
+}
+exports.isNodeContainedWithinNodeType = isNodeContainedWithinNodeType;
+function isSuiteEmpty(node) {
+    let sawEllipsis = false;
+    for (const statement of node.statements) {
+        if (statement.nodeType === 47 /* StatementList */) {
+            for (const substatement of statement.statements) {
+                if (substatement.nodeType === 18 /* Ellipsis */) {
+                    // Allow an ellipsis
+                    sawEllipsis = true;
+                }
+                else if (substatement.nodeType === 48 /* StringList */) {
+                    // Allow doc strings
+                }
+                else {
+                    return false;
+                }
+            }
+        }
+        else {
+            return false;
+        }
+    }
+    return sawEllipsis;
+}
+exports.isSuiteEmpty = isSuiteEmpty;
+function isMatchingExpression(reference, expression) {
+    if (reference.nodeType === 38 /* Name */) {
+        if (expression.nodeType === 38 /* Name */) {
+            return reference.value === expression.value;
+        }
+        else if (expression.nodeType === 4 /* AssignmentExpression */) {
+            return reference.value === expression.name.value;
+        }
+        return false;
+    }
+    else if (reference.nodeType === 35 /* MemberAccess */ &&
+        expression.nodeType === 35 /* MemberAccess */) {
+        return (isMatchingExpression(reference.leftExpression, expression.leftExpression) &&
+            reference.memberName.value === expression.memberName.value);
+    }
+    else if (reference.nodeType === 24 /* Index */ && expression.nodeType === 24 /* Index */) {
+        if (!isMatchingExpression(reference.baseExpression, expression.baseExpression)) {
+            return false;
+        }
+        if (expression.items.length !== 1 ||
+            expression.trailingComma ||
+            expression.items[0].name ||
+            expression.items[0].argumentCategory !== 0 /* Simple */) {
+            return false;
+        }
+        const expr = reference.items[0].valueExpression;
+        if (expr.nodeType === 40 /* Number */) {
+            const subscriptNode = expression.items[0].valueExpression;
+            if (subscriptNode.nodeType !== 40 /* Number */ ||
+                subscriptNode.isImaginary ||
+                !subscriptNode.isInteger) {
+                return false;
+            }
+            return expr.value === subscriptNode.value;
+        }
+        if (expr.nodeType === 55 /* UnaryOperation */ &&
+            expr.operator === 33 /* Subtract */ &&
+            expr.expression.nodeType === 40 /* Number */) {
+            const subscriptNode = expression.items[0].valueExpression;
+            if (subscriptNode.nodeType !== 55 /* UnaryOperation */ ||
+                subscriptNode.operator !== 33 /* Subtract */ ||
+                subscriptNode.expression.nodeType !== 40 /* Number */ ||
+                subscriptNode.expression.isImaginary ||
+                !subscriptNode.expression.isInteger) {
+                return false;
+            }
+            return expr.expression.value === subscriptNode.expression.value;
+        }
+        if (expr.nodeType === 48 /* StringList */) {
+            const referenceStringListNode = expr;
+            const subscriptNode = expression.items[0].valueExpression;
+            if (referenceStringListNode.strings.length === 1 &&
+                referenceStringListNode.strings[0].nodeType === 49 /* String */ &&
+                subscriptNode.nodeType === 48 /* StringList */ &&
+                subscriptNode.strings.length === 1 &&
+                subscriptNode.strings[0].nodeType === 49 /* String */) {
+                return referenceStringListNode.strings[0].value === subscriptNode.strings[0].value;
+            }
+        }
+        return false;
+    }
+    return false;
+}
+exports.isMatchingExpression = isMatchingExpression;
+function isPartialMatchingExpression(reference, expression) {
+    if (reference.nodeType === 35 /* MemberAccess */) {
+        return (isMatchingExpression(reference.leftExpression, expression) ||
+            isPartialMatchingExpression(reference.leftExpression, expression));
+    }
+    else if (reference.nodeType === 24 /* Index */) {
+        return (isMatchingExpression(reference.baseExpression, expression) ||
+            isPartialMatchingExpression(reference.baseExpression, expression));
+    }
+    return false;
+}
+exports.isPartialMatchingExpression = isPartialMatchingExpression;
+function isWithinDefaultParamInitializer(node) {
+    let curNode = node;
+    let prevNode;
+    while (curNode) {
+        if (curNode.nodeType === 41 /* Parameter */ && prevNode === curNode.defaultValue) {
+            return true;
+        }
+        if (curNode.nodeType === 30 /* Lambda */ ||
+            curNode.nodeType === 28 /* Function */ ||
+            curNode.nodeType === 10 /* Class */ ||
+            curNode.nodeType === 36 /* Module */) {
+            return false;
+        }
+        prevNode = curNode;
+        curNode = curNode.parent;
+    }
+    return false;
+}
+exports.isWithinDefaultParamInitializer = isWithinDefaultParamInitializer;
+function isWithinTypeAnnotation(node, requireQuotedAnnotation) {
+    let curNode = node;
+    let prevNode;
+    let isQuoted = false;
+    while (curNode) {
+        if (curNode.nodeType === 41 /* Parameter */ &&
+            (prevNode === curNode.typeAnnotation || prevNode === curNode.typeAnnotationComment)) {
+            return isQuoted || !requireQuotedAnnotation;
+        }
+        if (curNode.nodeType === 28 /* Function */ && prevNode === curNode.returnTypeAnnotation) {
+            return isQuoted || !requireQuotedAnnotation;
+        }
+        if (curNode.nodeType === 28 /* Function */ && prevNode === curNode.functionAnnotationComment) {
+            // Type comments are always considered forward declarations even though
+            // they're not "quoted".
+            return true;
+        }
+        if (curNode.nodeType === 54 /* TypeAnnotation */ && prevNode === curNode.typeAnnotation) {
+            return isQuoted || !requireQuotedAnnotation;
+        }
+        if (curNode.nodeType === 3 /* Assignment */ && prevNode === curNode.typeAnnotationComment) {
+            // Type comments are always considered forward declarations even though
+            // they're not "quoted".
+            return true;
+        }
+        if (curNode.nodeType === 48 /* StringList */ && prevNode === curNode.typeAnnotation) {
+            isQuoted = true;
+        }
+        if (curNode.nodeType === 30 /* Lambda */ ||
+            curNode.nodeType === 28 /* Function */ ||
+            curNode.nodeType === 10 /* Class */ ||
+            curNode.nodeType === 36 /* Module */) {
+            return false;
+        }
+        prevNode = curNode;
+        curNode = curNode.parent;
+    }
+    return false;
+}
+exports.isWithinTypeAnnotation = isWithinTypeAnnotation;
+function isWithinAnnotationComment(node) {
+    let curNode = node;
+    let prevNode;
+    while (curNode) {
+        if (curNode.nodeType === 28 /* Function */ && prevNode === curNode.functionAnnotationComment) {
+            // Type comments are always considered forward declarations even though
+            // they're not "quoted".
+            return true;
+        }
+        if (curNode.nodeType === 3 /* Assignment */ && prevNode === curNode.typeAnnotationComment) {
+            // Type comments are always considered forward declarations even though
+            // they're not "quoted".
+            return true;
+        }
+        if (curNode.nodeType === 30 /* Lambda */ ||
+            curNode.nodeType === 28 /* Function */ ||
+            curNode.nodeType === 10 /* Class */ ||
+            curNode.nodeType === 36 /* Module */) {
+            return false;
+        }
+        prevNode = curNode;
+        curNode = curNode.parent;
+    }
+    return false;
+}
+exports.isWithinAnnotationComment = isWithinAnnotationComment;
+function isWithinLoop(node) {
+    let curNode = node;
+    while (curNode) {
+        switch (curNode.nodeType) {
+            case 26 /* For */:
+            case 57 /* While */: {
+                return true;
+            }
+            case 36 /* Module */: {
+                break;
+            }
+        }
+        curNode = curNode.parent;
+    }
+    return false;
+}
+exports.isWithinLoop = isWithinLoop;
+function isWithinTryBlock(node, treatWithAsTryBlock = false) {
+    let curNode = node;
+    let prevNode;
+    while (curNode) {
+        switch (curNode.nodeType) {
+            case 53 /* Try */: {
+                return curNode.trySuite === prevNode;
+            }
+            case 58 /* With */: {
+                if (treatWithAsTryBlock && curNode.suite === prevNode) {
+                    return true;
+                }
+                break;
+            }
+            case 28 /* Function */:
+            case 36 /* Module */:
+            case 10 /* Class */: {
+                return false;
+            }
+        }
+        prevNode = curNode;
+        curNode = curNode.parent;
+    }
+    return false;
+}
+exports.isWithinTryBlock = isWithinTryBlock;
+function isWithinAssertExpression(node) {
+    let curNode = node;
+    let prevNode;
+    while (curNode) {
+        switch (curNode.nodeType) {
+            case 2 /* Assert */: {
+                return curNode.testExpression === prevNode;
+            }
+        }
+        prevNode = curNode;
+        curNode = curNode.parent;
+    }
+    return false;
+}
+exports.isWithinAssertExpression = isWithinAssertExpression;
+function getDocString(statements) {
+    // See if the first statement in the suite is a triple-quote string.
+    if (statements.length === 0) {
+        return undefined;
+    }
+    if (statements[0].nodeType !== 47 /* StatementList */) {
+        return undefined;
+    }
+    if (!isDocString(statements[0])) {
+        return undefined;
+    }
+    // It's up to the user to convert normalize/convert this as needed.
+    const strings = statements[0].statements[0].strings;
+    if (strings.length === 1) {
+        // Common case.
+        return strings[0].value;
+    }
+    return strings.map((s) => s.value).join('');
+}
+exports.getDocString = getDocString;
+function isDocString(statementList) {
+    // If the first statement in the suite isn't a StringNode,
+    // assume there is no docString.
+    if (statementList.statements.length === 0 || statementList.statements[0].nodeType !== 48 /* StringList */) {
+        return false;
+    }
+    // A docstring can consist of multiple joined strings in a single expression.
+    const strings = statementList.statements[0].strings;
+    if (strings.length === 0) {
+        return false;
+    }
+    // Any f-strings invalidate the entire docstring.
+    if (strings.some((n) => (n.token.flags & 64 /* Format */) !== 0)) {
+        return false;
+    }
+    // It's up to the user to convert normalize/convert this as needed.
+    return true;
+}
+exports.isDocString = isDocString;
+// Sometimes a NamedTuple assignment statement is followed by a statement
+// that looks like the following:
+//    MyNamedTuple.__new__.__defaults__ = ...
+// This pattern is commonly used to set the default values that are
+// not specified in the original list.
+function isAssignmentToDefaultsFollowingNamedTuple(callNode) {
+    var _a, _b;
+    if (callNode.nodeType !== 9 /* Call */ ||
+        !callNode.parent ||
+        callNode.parent.nodeType !== 3 /* Assignment */ ||
+        callNode.parent.leftExpression.nodeType !== 38 /* Name */ ||
+        !callNode.parent.parent ||
+        callNode.parent.parent.nodeType !== 47 /* StatementList */) {
+        return false;
+    }
+    const namedTupleAssignedName = callNode.parent.leftExpression.value;
+    const statementList = callNode.parent.parent;
+    if (statementList.statements[0] !== callNode.parent ||
+        !statementList.parent ||
+        !(statementList.parent.nodeType === 36 /* Module */ ||
+            statementList.parent.nodeType === 50 /* Suite */)) {
+        return false;
+    }
+    const moduleOrSuite = statementList.parent;
+    let statementIndex = moduleOrSuite.statements.findIndex((s) => s === statementList);
+    if (statementIndex < 0) {
+        return false;
+    }
+    statementIndex++;
+    while (statementIndex < moduleOrSuite.statements.length) {
+        const nextStatement = moduleOrSuite.statements[statementIndex];
+        if (nextStatement.nodeType !== 47 /* StatementList */) {
+            break;
+        }
+        if (((_a = nextStatement.statements[0]) === null || _a === void 0 ? void 0 : _a.nodeType) === 48 /* StringList */) {
+            // Skip over comments
+            statementIndex++;
+            continue;
+        }
+        if (((_b = nextStatement.statements[0]) === null || _b === void 0 ? void 0 : _b.nodeType) === 3 /* Assignment */) {
+            const assignNode = nextStatement.statements[0];
+            if (assignNode.leftExpression.nodeType === 35 /* MemberAccess */ &&
+                assignNode.leftExpression.memberName.value === '__defaults__') {
+                const defaultTarget = assignNode.leftExpression.leftExpression;
+                if (defaultTarget.nodeType === 35 /* MemberAccess */ &&
+                    defaultTarget.memberName.value === '__new__' &&
+                    defaultTarget.leftExpression.nodeType === 38 /* Name */ &&
+                    defaultTarget.leftExpression.value === namedTupleAssignedName) {
+                    return true;
+                }
+            }
+        }
+        break;
+    }
+    return false;
+}
+exports.isAssignmentToDefaultsFollowingNamedTuple = isAssignmentToDefaultsFollowingNamedTuple;
+// This simple parse tree walker calls a callback function
+// for each NameNode it encounters.
+class NameNodeWalker extends parseTreeWalker_1.ParseTreeWalker {
+    constructor(_callback) {
+        super();
+        this._callback = _callback;
+    }
+    visitName(node) {
+        this._callback(node, this._subscriptIndex, this._baseExpression);
+        return true;
+    }
+    visitIndex(node) {
+        this.walk(node.baseExpression);
+        const prevSubscriptIndex = this._subscriptIndex;
+        const prevBaseExpression = this._baseExpression;
+        this._baseExpression = node.baseExpression;
+        node.items.forEach((item, index) => {
+            this._subscriptIndex = index;
+            this.walk(item);
+        });
+        this._subscriptIndex = prevSubscriptIndex;
+        this._baseExpression = prevBaseExpression;
+        return false;
+    }
+}
+exports.NameNodeWalker = NameNodeWalker;
+class CallNodeWalker extends parseTreeWalker_1.ParseTreeWalker {
+    constructor(_callback) {
+        super();
+        this._callback = _callback;
+    }
+    visitCall(node) {
+        this._callback(node);
+        return true;
+    }
+}
+exports.CallNodeWalker = CallNodeWalker;
+function getEnclosingParameter(node) {
+    let curNode = node;
+    while (curNode) {
+        if (curNode.nodeType === 41 /* Parameter */) {
+            return curNode;
+        }
+        curNode = curNode.parent;
+    }
+    return undefined;
+}
+exports.getEnclosingParameter = getEnclosingParameter;
+function getCallNodeAndActiveParameterIndex(node, insertionOffset, tokens) {
+    // Find the call node that contains the specified node.
+    let curNode = node;
+    let callNode;
+    while (curNode !== undefined) {
+        // make sure we only look at callNodes when we are inside their arguments
+        if (curNode.nodeType === 9 /* Call */) {
+            if (isOffsetInsideCallArgs(curNode, insertionOffset)) {
+                callNode = curNode;
+                break;
+            }
+        }
+        curNode = curNode.parent;
+    }
+    if (!callNode || !callNode.arguments) {
+        return undefined;
+    }
+    const endPosition = textRange_1.TextRange.getEnd(callNode);
+    if (insertionOffset > endPosition) {
+        return undefined;
+    }
+    const tokenAtEnd = getTokenAt(tokens, endPosition - 1);
+    if (insertionOffset === endPosition && (tokenAtEnd === null || tokenAtEnd === void 0 ? void 0 : tokenAtEnd.type) === 14 /* CloseParenthesis */) {
+        return undefined;
+    }
+    let addedActive = false;
+    let activeIndex = -1;
+    let activeOrFake = false;
+    callNode.arguments.forEach((arg, index) => {
+        if (addedActive) {
+            return;
+        }
+        // Calculate the argument's bounds including whitespace and colons.
+        let start = arg.start;
+        const startTokenIndex = tokens.getItemAtPosition(start);
+        if (startTokenIndex >= 0) {
+            start = textRange_1.TextRange.getEnd(tokens.getItemAt(startTokenIndex - 1));
+        }
+        let end = textRange_1.TextRange.getEnd(arg);
+        const endTokenIndex = tokens.getItemAtPosition(end);
+        if (endTokenIndex >= 0) {
+            // Find the true end of the argument by searching for the
+            // terminating comma or parenthesis.
+            for (let i = endTokenIndex; i < tokens.count; i++) {
+                const tok = tokens.getItemAt(i);
+                switch (tok.type) {
+                    case 12 /* Comma */:
+                    case 14 /* CloseParenthesis */:
+                        break;
+                    default:
+                        continue;
+                }
+                end = textRange_1.TextRange.getEnd(tok);
+                break;
+            }
+        }
+        if (insertionOffset < end) {
+            activeIndex = index;
+            activeOrFake = insertionOffset >= start;
+            addedActive = true;
+        }
+    });
+    if (!addedActive) {
+        activeIndex = callNode.arguments.length + 1;
+    }
+    return {
+        callNode,
+        activeIndex,
+        activeOrFake,
+    };
+    function isOffsetInsideCallArgs(node, offset) {
+        let found = true;
+        const argumentStart = node.leftExpression.length > 0 ? textRange_1.TextRange.getEnd(node.leftExpression) - 1 : node.leftExpression.start;
+        const index = tokens.getItemAtPosition(argumentStart);
+        if (index >= 0 && index + 1 < tokens.count) {
+            const token = tokens.getItemAt(index + 1);
+            if (token.type === 13 /* OpenParenthesis */ && insertionOffset < textRange_1.TextRange.getEnd(token)) {
+                // position must be after '('
+                found = false;
+            }
+        }
+        return found;
+    }
+}
+exports.getCallNodeAndActiveParameterIndex = getCallNodeAndActiveParameterIndex;
+function getTokenAt(tokens, position) {
+    const index = tokens.getItemAtPosition(position);
+    if (index < 0) {
+        return undefined;
+    }
+    return tokens.getItemAt(index);
+}
+exports.getTokenAt = getTokenAt;
+function getTokenOverlapping(tokens, position) {
+    const index = tokens.getItemAtPosition(position);
+    if (index < 0) {
+        return undefined;
+    }
+    const token = tokens.getItemAt(index);
+    return textRange_1.TextRange.overlaps(token, position) ? token : undefined;
+}
+exports.getTokenOverlapping = getTokenOverlapping;
+function printParseNodeType(type) {
+    switch (type) {
+        case 0 /* Error */:
+            return 'Error';
+        case 1 /* Argument */:
+            return 'Argument';
+        case 2 /* Assert */:
+            return 'Assert';
+        case 3 /* Assignment */:
+            return 'Assignment';
+        case 4 /* AssignmentExpression */:
+            return 'AssignmentExpression';
+        case 5 /* AugmentedAssignment */:
+            return 'AugmentedAssignment';
+        case 6 /* Await */:
+            return 'Await';
+        case 7 /* BinaryOperation */:
+            return 'BinaryOperation';
+        case 8 /* Break */:
+            return 'Break';
+        case 9 /* Call */:
+            return 'Call';
+        case 10 /* Class */:
+            return 'Class';
+        case 11 /* Constant */:
+            return 'Constant';
+        case 12 /* Continue */:
+            return 'Continue';
+        case 13 /* Decorator */:
+            return 'Decorator';
+        case 14 /* Del */:
+            return 'Del';
+        case 15 /* Dictionary */:
+            return 'Dictionary';
+        case 16 /* DictionaryExpandEntry */:
+            return 'DictionaryExpandEntry';
+        case 17 /* DictionaryKeyEntry */:
+            return 'DictionaryKeyEntry';
+        case 18 /* Ellipsis */:
+            return 'Ellipsis';
+        case 19 /* If */:
+            return 'If';
+        case 20 /* Import */:
+            return 'Import';
+        case 21 /* ImportAs */:
+            return 'ImportAs';
+        case 22 /* ImportFrom */:
+            return 'ImportFrom';
+        case 23 /* ImportFromAs */:
+            return 'ImportFromAs';
+        case 24 /* Index */:
+            return 'Index';
+        case 25 /* Except */:
+            return 'Except';
+        case 26 /* For */:
+            return 'For';
+        case 27 /* FormatString */:
+            return 'FormatString';
+        case 28 /* Function */:
+            return 'Function';
+        case 29 /* Global */:
+            return 'Global';
+        case 30 /* Lambda */:
+            return 'Lambda';
+        case 31 /* List */:
+            return 'List';
+        case 32 /* ListComprehension */:
+            return 'ListComprehension';
+        case 33 /* ListComprehensionFor */:
+            return 'ListComprehensionFor';
+        case 34 /* ListComprehensionIf */:
+            return 'ListComprehensionIf';
+        case 35 /* MemberAccess */:
+            return 'MemberAccess';
+        case 36 /* Module */:
+            return 'Module';
+        case 37 /* ModuleName */:
+            return 'ModuleName';
+        case 38 /* Name */:
+            return 'Name';
+        case 39 /* Nonlocal */:
+            return 'Nonlocal';
+        case 40 /* Number */:
+            return 'Number';
+        case 41 /* Parameter */:
+            return 'Parameter';
+        case 42 /* Pass */:
+            return 'Pass';
+        case 43 /* Raise */:
+            return 'Raise';
+        case 44 /* Return */:
+            return 'Return';
+        case 45 /* Set */:
+            return 'Set';
+        case 46 /* Slice */:
+            return 'Slice';
+        case 47 /* StatementList */:
+            return 'StatementList';
+        case 48 /* StringList */:
+            return 'StringList';
+        case 49 /* String */:
+            return 'String';
+        case 50 /* Suite */:
+            return 'Suite';
+        case 51 /* Ternary */:
+            return 'Ternary';
+        case 52 /* Tuple */:
+            return 'Tuple';
+        case 53 /* Try */:
+            return 'Try';
+        case 54 /* TypeAnnotation */:
+            return 'TypeAnnotation';
+        case 55 /* UnaryOperation */:
+            return 'UnaryOperation';
+        case 56 /* Unpack */:
+            return 'Unpack';
+        case 57 /* While */:
+            return 'While';
+        case 58 /* With */:
+            return 'With';
+        case 59 /* WithItem */:
+            return 'WithItem';
+        case 60 /* Yield */:
+            return 'Yield';
+        case 61 /* YieldFrom */:
+            return 'YieldFrom';
+        case 62 /* FunctionAnnotation */:
+            return 'FunctionAnnotation';
+        case 63 /* Match */:
+            return 'Match';
+        case 64 /* Case */:
+            return 'Case';
+        case 65 /* PatternSequence */:
+            return 'PatternSequence';
+        case 66 /* PatternAs */:
+            return 'PatternAs';
+        case 67 /* PatternLiteral */:
+            return 'PatternLiteral';
+        case 68 /* PatternClass */:
+            return 'PatternClass';
+        case 69 /* PatternCapture */:
+            return 'PatternCapture';
+        case 70 /* PatternMapping */:
+            return 'PatternMapping';
+        case 71 /* PatternMappingKeyEntry */:
+            return 'PatternMappingKeyEntry';
+        case 72 /* PatternMappingExpandEntry */:
+            return 'PatternMappingExpandEntry';
+        case 73 /* PatternValue */:
+            return 'PatternValue';
+        case 74 /* PatternClassArgument */:
+            return 'PatternClassArgument';
+    }
+    (0, debug_1.assertNever)(type);
+}
+exports.printParseNodeType = printParseNodeType;
+function isWriteAccess(node) {
+    let prevNode = node;
+    let curNode = prevNode.parent;
+    while (curNode) {
+        switch (curNode.nodeType) {
+            case 3 /* Assignment */: {
+                return prevNode === curNode.leftExpression;
+            }
+            case 5 /* AugmentedAssignment */: {
+                return prevNode === curNode.leftExpression;
+            }
+            case 4 /* AssignmentExpression */: {
+                return prevNode === curNode.name;
+            }
+            case 14 /* Del */: {
+                return true;
+            }
+            case 26 /* For */: {
+                return prevNode === curNode.targetExpression;
+            }
+            case 21 /* ImportAs */: {
+                return (prevNode === curNode.alias ||
+                    (curNode.module.nameParts.length > 0 && prevNode === curNode.module.nameParts[0]));
+            }
+            case 23 /* ImportFromAs */: {
+                return prevNode === curNode.alias || (!curNode.alias && prevNode === curNode.name);
+            }
+            case 35 /* MemberAccess */: {
+                if (prevNode !== curNode.memberName) {
+                    return false;
+                }
+                break;
+            }
+            case 25 /* Except */: {
+                return prevNode === curNode.name;
+            }
+            case 58 /* With */: {
+                return curNode.withItems.some((item) => item === prevNode);
+            }
+            case 33 /* ListComprehensionFor */: {
+                return prevNode === curNode.targetExpression;
+            }
+            case 54 /* TypeAnnotation */: {
+                if (prevNode === curNode.typeAnnotation) {
+                    return false;
+                }
+                break;
+            }
+            case 28 /* Function */:
+            case 10 /* Class */:
+            case 36 /* Module */: {
+                return false;
+            }
+        }
+        prevNode = curNode;
+        curNode = curNode.parent;
+    }
+    return false;
+}
+exports.isWriteAccess = isWriteAccess;
+function getModuleNode(node) {
+    let current = node;
+    while (current && current.nodeType !== 36 /* Module */) {
+        current = current.parent;
+    }
+    return current;
+}
+exports.getModuleNode = getModuleNode;
+function getFileInfoFromNode(node) {
+    const current = getModuleNode(node);
+    return current ? AnalyzerNodeInfo.getFileInfo(current) : undefined;
+}
+exports.getFileInfoFromNode = getFileInfoFromNode;
+function isFunctionSuiteEmpty(node) {
+    let isEmpty = true;
+    node.suite.statements.forEach((statement) => {
+        if (statement.nodeType === 0 /* Error */) {
+            return;
+        }
+        else if (statement.nodeType === 47 /* StatementList */) {
+            statement.statements.forEach((subStatement) => {
+                // Allow docstrings, ellipsis, and pass statements.
+                if (subStatement.nodeType !== 18 /* Ellipsis */ &&
+                    subStatement.nodeType !== 48 /* StringList */ &&
+                    subStatement.nodeType !== 42 /* Pass */) {
+                    isEmpty = false;
+                }
+            });
+        }
+        else {
+            isEmpty = false;
+        }
+    });
+    return isEmpty;
+}
+exports.isFunctionSuiteEmpty = isFunctionSuiteEmpty;
+function getTypeAnnotationForParameter(node, paramIndex) {
+    if (paramIndex >= node.parameters.length) {
+        return undefined;
+    }
+    const param = node.parameters[paramIndex];
+    if (param.typeAnnotation) {
+        return param.typeAnnotation;
+    }
+    else if (param.typeAnnotationComment) {
+        return param.typeAnnotationComment;
+    }
+    if (!node.functionAnnotationComment || node.functionAnnotationComment.isParamListEllipsis) {
+        return undefined;
+    }
+    let firstCommentAnnotationIndex = 0;
+    const paramAnnotations = node.functionAnnotationComment.paramTypeAnnotations;
+    if (paramAnnotations.length < node.parameters.length) {
+        firstCommentAnnotationIndex = 1;
+    }
+    const adjIndex = paramIndex - firstCommentAnnotationIndex;
+    if (adjIndex < 0 || adjIndex >= paramAnnotations.length) {
+        return undefined;
+    }
+    return paramAnnotations[adjIndex];
+}
+exports.getTypeAnnotationForParameter = getTypeAnnotationForParameter;
+function isImportModuleName(node) {
+    var _a, _b;
+    return ((_b = (_a = getFirstAncestorOrSelfOfKind(node, 37 /* ModuleName */)) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 21 /* ImportAs */;
+}
+exports.isImportModuleName = isImportModuleName;
+function isImportAlias(node) {
+    var _a;
+    return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 21 /* ImportAs */ && node.parent.alias === node;
+}
+exports.isImportAlias = isImportAlias;
+function isFromImportModuleName(node) {
+    var _a, _b;
+    return ((_b = (_a = getFirstAncestorOrSelfOfKind(node, 37 /* ModuleName */)) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 22 /* ImportFrom */;
+}
+exports.isFromImportModuleName = isFromImportModuleName;
+function isFromImportName(node) {
+    var _a;
+    return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 23 /* ImportFromAs */ && node.parent.name === node;
+}
+exports.isFromImportName = isFromImportName;
+function isFromImportAlias(node) {
+    var _a;
+    return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 23 /* ImportFromAs */ && node.parent.alias === node;
+}
+exports.isFromImportAlias = isFromImportAlias;
+function isLastNameOfModuleName(node) {
+    var _a;
+    if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 37 /* ModuleName */) {
+        return false;
+    }
+    const module = node.parent;
+    if (module.nameParts.length === 0) {
+        return false;
+    }
+    return module.nameParts[module.nameParts.length - 1] === node;
+}
+exports.isLastNameOfModuleName = isLastNameOfModuleName;
+function* _getAncestorsIncludingSelf(node) {
+    while (node !== undefined) {
+        yield node;
+        node = node.parent;
+    }
+}
+function getFirstAncestorOrSelfOfKind(node, type) {
+    return getFirstAncestorOrSelf(node, (n) => n.nodeType === type);
+}
+exports.getFirstAncestorOrSelfOfKind = getFirstAncestorOrSelfOfKind;
+function getFirstAncestorOrSelf(node, predicate) {
+    for (const current of _getAncestorsIncludingSelf(node)) {
+        if (predicate(current)) {
+            return current;
+        }
+    }
+    return undefined;
+}
+exports.getFirstAncestorOrSelf = getFirstAncestorOrSelf;
+function getDottedNameWithGivenNodeAsLastName(node) {
+    var _a;
+    // Shape of dotted name is
+    //    MemberAccess (ex, a.b)
+    //  Name        Name
+    // or
+    //           MemberAccess (ex, a.b.c)
+    //    MemberAccess     Name
+    //  Name       Name
+    if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 35 /* MemberAccess */) {
+        return node;
+    }
+    if (node.parent.leftExpression === node) {
+        return node;
+    }
+    return node.parent;
+}
+exports.getDottedNameWithGivenNodeAsLastName = getDottedNameWithGivenNodeAsLastName;
+function getDottedName(node) {
+    // ex) [a] or [a].b
+    // simple case, [a]
+    if (node.nodeType === 38 /* Name */) {
+        return [node];
+    }
+    // dotted name case.
+    const names = [];
+    if (_getDottedName(node, names)) {
+        return names.reverse();
+    }
+    return undefined;
+    function _getDottedName(node, names) {
+        if (node.nodeType === 38 /* Name */) {
+            names.push(node);
+            return true;
+        }
+        names.push(node.memberName);
+        if (node.leftExpression.nodeType === 38 /* Name */ ||
+            node.leftExpression.nodeType === 35 /* MemberAccess */) {
+            return _getDottedName(node.leftExpression, names);
+        }
+        return false;
+    }
+}
+exports.getDottedName = getDottedName;
+function getFirstNameOfDottedName(node) {
+    // ex) [a] or [a].b
+    if (node.nodeType === 38 /* Name */) {
+        return node;
+    }
+    if (node.leftExpression.nodeType === 38 /* Name */ ||
+        node.leftExpression.nodeType === 35 /* MemberAccess */) {
+        return getFirstNameOfDottedName(node.leftExpression);
+    }
+    return undefined;
+}
+exports.getFirstNameOfDottedName = getFirstNameOfDottedName;
+function isFirstNameOfDottedName(node) {
+    var _a;
+    // ex) [A] or [A].B.C.D
+    if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 35 /* MemberAccess */) {
+        return true;
+    }
+    if (node.parent.leftExpression === node) {
+        return true;
+    }
+    return false;
+}
+exports.isFirstNameOfDottedName = isFirstNameOfDottedName;
+function isLastNameOfDottedName(node) {
+    var _a, _b;
+    // ex) A or D.C.B.[A]
+    if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 35 /* MemberAccess */) {
+        return true;
+    }
+    if (node.parent.leftExpression.nodeType !== 38 /* Name */ &&
+        node.parent.leftExpression.nodeType !== 35 /* MemberAccess */) {
+        return false;
+    }
+    if (node.parent.leftExpression === node) {
+        return false;
+    }
+    return ((_b = node.parent.parent) === null || _b === void 0 ? void 0 : _b.nodeType) !== 35 /* MemberAccess */;
+}
+exports.isLastNameOfDottedName = isLastNameOfDottedName;
+function getStringNodeValueRange(node) {
+    return getStringValueRange(node.token);
+}
+exports.getStringNodeValueRange = getStringNodeValueRange;
+function getStringValueRange(token) {
+    const length = token.quoteMarkLength;
+    const hasEnding = !(token.flags & 65536 /* Unterminated */);
+    return textRange_1.TextRange.create(token.start + length, token.length - length - (hasEnding ? length : 0));
+}
+exports.getStringValueRange = getStringValueRange;
+function getFullStatementRange(statementNode, tokenizerOutput) {
+    const range = (0, positionUtils_1.convertTextRangeToRange)(statementNode, tokenizerOutput.lines);
+    // First, see whether there are other tokens except semicolon or new line on the same line.
+    const endPosition = _getEndPositionIfMultipleStatementsAreOnSameLine(range, textRange_1.TextRange.getEnd(statementNode), tokenizerOutput);
+    if (endPosition) {
+        return { start: range.start, end: endPosition };
+    }
+    // If not, delete the whole line.
+    if (range.end.line === tokenizerOutput.lines.count - 1) {
+        return range;
+    }
+    return { start: range.start, end: { line: range.end.line + 1, character: 0 } };
+}
+exports.getFullStatementRange = getFullStatementRange;
+function isUnannotatedFunction(node) {
+    return (node.returnTypeAnnotation === undefined &&
+        node.parameters.every((param) => param.typeAnnotation === undefined && param.typeAnnotationComment === undefined));
+}
+exports.isUnannotatedFunction = isUnannotatedFunction;
+function _getEndPositionIfMultipleStatementsAreOnSameLine(range, tokenPosition, tokenizerOutput) {
+    const tokenIndex = tokenizerOutput.tokens.getItemAtPosition(tokenPosition);
+    if (tokenIndex < 0) {
+        return undefined;
+    }
+    let currentIndex = tokenIndex;
+    for (; currentIndex < tokenizerOutput.tokens.count; currentIndex++) {
+        const token = tokenizerOutput.tokens.getItemAt(currentIndex);
+        const tokenRange = (0, positionUtils_1.convertTextRangeToRange)(token, tokenizerOutput.lines);
+        if (range.end.line !== tokenRange.start.line) {
+            break;
+        }
+    }
+    for (let index = tokenIndex; index < currentIndex; index++) {
+        const token = tokenizerOutput.tokens.getItemAt(index);
+        if (token.type === 11 /* Semicolon */ || token.type === 2 /* NewLine */) {
+            continue;
+        }
+        const tokenRange = (0, positionUtils_1.convertTextRangeToRange)(token, tokenizerOutput.lines);
+        return tokenRange.start;
+    }
+    return undefined;
+}
+//# sourceMappingURL=parseTreeUtils.js.map