@zzzen/pyright-internal 1.1.254

package/dist/parser/parseNodes.js

@@ -0,0 +1,1406 @@
+"use strict";
+/*
+ * parseNodes.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * Definition of parse nodes that make up the Python abstract
+ * syntax tree (AST).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetNode = exports.DictionaryExpandEntryNode = exports.DictionaryKeyEntryNode = exports.DictionaryNode = exports.StringListNode = exports.FormatStringNode = exports.StringNode = exports.NumberNode = exports.EllipsisNode = exports.ConstantNode = exports.NameNode = exports.LambdaNode = exports.MemberAccessNode = exports.YieldFromNode = exports.YieldNode = exports.SliceNode = exports.IndexNode = exports.ListComprehensionNode = exports.CallNode = exports.TupleNode = exports.UnpackNode = exports.TernaryNode = exports.AwaitNode = exports.AugmentedAssignmentNode = exports.FunctionAnnotationNode = exports.TypeAnnotationNode = exports.AssignmentNode = exports.AssignmentExpressionNode = exports.BinaryOperationNode = exports.UnaryOperationNode = exports.ErrorNode = exports.isExpressionNode = exports.StatementListNode = exports.DecoratorNode = exports.WithItemNode = exports.WithNode = exports.ClassNode = exports.ParameterNode = exports.FunctionNode = exports.ExceptNode = exports.TryNode = exports.ListComprehensionIfNode = exports.ListComprehensionForNode = exports.ForNode = exports.WhileNode = exports.IfNode = exports.SuiteNode = exports.ModuleNode = exports.extendRange = exports.getNextNodeId = void 0;
+exports.PatternValueNode = exports.PatternMappingExpandEntryNode = exports.PatternMappingKeyEntryNode = exports.PatternMappingNode = exports.PatternCaptureNode = exports.PatternClassArgumentNode = exports.PatternClassNode = exports.PatternLiteralNode = exports.PatternAsNode = exports.PatternSequenceNode = exports.CaseNode = exports.MatchNode = exports.RaiseNode = exports.ReturnNode = exports.ContinueNode = exports.BreakNode = exports.AssertNode = exports.NonlocalNode = exports.GlobalNode = exports.ImportFromAsNode = exports.ImportFromNode = exports.ImportAsNode = exports.ModuleNameNode = exports.ImportNode = exports.PassNode = exports.DelNode = exports.ArgumentNode = exports.ListNode = void 0;
+const textRange_1 = require("../common/textRange");
+let _nextNodeId = 1;
+function getNextNodeId() {
+    return _nextNodeId++;
+}
+exports.getNextNodeId = getNextNodeId;
+function extendRange(node, newRange) {
+    if (newRange.start < node.start) {
+        node.length += node.start - newRange.start;
+        node.start = newRange.start;
+    }
+    if (textRange_1.TextRange.getEnd(newRange) > textRange_1.TextRange.getEnd(node)) {
+        node.length = textRange_1.TextRange.getEnd(newRange) - node.start;
+    }
+}
+exports.extendRange = extendRange;
+var ModuleNode;
+(function (ModuleNode) {
+    function create(range) {
+        const node = {
+            start: range.start,
+            length: range.length,
+            nodeType: 36 /* Module */,
+            id: _nextNodeId++,
+            statements: [],
+        };
+        return node;
+    }
+    ModuleNode.create = create;
+})(ModuleNode = exports.ModuleNode || (exports.ModuleNode = {}));
+var SuiteNode;
+(function (SuiteNode) {
+    function create(range) {
+        const node = {
+            start: range.start,
+            length: range.length,
+            nodeType: 50 /* Suite */,
+            id: _nextNodeId++,
+            statements: [],
+        };
+        return node;
+    }
+    SuiteNode.create = create;
+})(SuiteNode = exports.SuiteNode || (exports.SuiteNode = {}));
+var IfNode;
+(function (IfNode) {
+    function create(ifOrElifToken, testExpression, ifSuite, elseSuite) {
+        const node = {
+            start: ifOrElifToken.start,
+            length: ifOrElifToken.length,
+            nodeType: 19 /* If */,
+            id: _nextNodeId++,
+            testExpression,
+            ifSuite,
+            elseSuite,
+        };
+        testExpression.parent = node;
+        ifSuite.parent = node;
+        extendRange(node, testExpression);
+        extendRange(node, ifSuite);
+        if (elseSuite) {
+            extendRange(node, elseSuite);
+            elseSuite.parent = node;
+        }
+        return node;
+    }
+    IfNode.create = create;
+})(IfNode = exports.IfNode || (exports.IfNode = {}));
+var WhileNode;
+(function (WhileNode) {
+    function create(whileToken, testExpression, whileSuite) {
+        const node = {
+            start: whileToken.start,
+            length: whileToken.length,
+            nodeType: 57 /* While */,
+            id: _nextNodeId++,
+            testExpression,
+            whileSuite,
+        };
+        testExpression.parent = node;
+        whileSuite.parent = node;
+        extendRange(node, whileSuite);
+        return node;
+    }
+    WhileNode.create = create;
+})(WhileNode = exports.WhileNode || (exports.WhileNode = {}));
+var ForNode;
+(function (ForNode) {
+    function create(forToken, targetExpression, iterableExpression, forSuite) {
+        const node = {
+            start: forToken.start,
+            length: forToken.length,
+            nodeType: 26 /* For */,
+            id: _nextNodeId++,
+            targetExpression,
+            iterableExpression,
+            forSuite,
+        };
+        targetExpression.parent = node;
+        iterableExpression.parent = node;
+        forSuite.parent = node;
+        extendRange(node, forSuite);
+        return node;
+    }
+    ForNode.create = create;
+})(ForNode = exports.ForNode || (exports.ForNode = {}));
+var ListComprehensionForNode;
+(function (ListComprehensionForNode) {
+    function create(startToken, targetExpression, iterableExpression) {
+        const node = {
+            start: startToken.start,
+            length: startToken.length,
+            nodeType: 33 /* ListComprehensionFor */,
+            id: _nextNodeId++,
+            targetExpression,
+            iterableExpression,
+        };
+        targetExpression.parent = node;
+        iterableExpression.parent = node;
+        extendRange(node, targetExpression);
+        extendRange(node, iterableExpression);
+        return node;
+    }
+    ListComprehensionForNode.create = create;
+})(ListComprehensionForNode = exports.ListComprehensionForNode || (exports.ListComprehensionForNode = {}));
+var ListComprehensionIfNode;
+(function (ListComprehensionIfNode) {
+    function create(ifToken, testExpression) {
+        const node = {
+            start: ifToken.start,
+            length: ifToken.length,
+            nodeType: 34 /* ListComprehensionIf */,
+            id: _nextNodeId++,
+            testExpression,
+        };
+        testExpression.parent = node;
+        extendRange(node, testExpression);
+        return node;
+    }
+    ListComprehensionIfNode.create = create;
+})(ListComprehensionIfNode = exports.ListComprehensionIfNode || (exports.ListComprehensionIfNode = {}));
+var TryNode;
+(function (TryNode) {
+    function create(tryToken, trySuite) {
+        const node = {
+            start: tryToken.start,
+            length: tryToken.length,
+            nodeType: 53 /* Try */,
+            id: _nextNodeId++,
+            trySuite,
+            exceptClauses: [],
+        };
+        trySuite.parent = node;
+        extendRange(node, trySuite);
+        return node;
+    }
+    TryNode.create = create;
+})(TryNode = exports.TryNode || (exports.TryNode = {}));
+var ExceptNode;
+(function (ExceptNode) {
+    function create(exceptToken, exceptSuite, isExceptGroup) {
+        const node = {
+            start: exceptToken.start,
+            length: exceptToken.length,
+            nodeType: 25 /* Except */,
+            id: _nextNodeId++,
+            exceptSuite,
+            isExceptGroup,
+        };
+        exceptSuite.parent = node;
+        extendRange(node, exceptSuite);
+        return node;
+    }
+    ExceptNode.create = create;
+})(ExceptNode = exports.ExceptNode || (exports.ExceptNode = {}));
+var FunctionNode;
+(function (FunctionNode) {
+    function create(defToken, name, suite) {
+        const node = {
+            start: defToken.start,
+            length: defToken.length,
+            nodeType: 28 /* Function */,
+            id: _nextNodeId++,
+            decorators: [],
+            name,
+            parameters: [],
+            suite,
+        };
+        name.parent = node;
+        suite.parent = node;
+        extendRange(node, suite);
+        return node;
+    }
+    FunctionNode.create = create;
+})(FunctionNode = exports.FunctionNode || (exports.FunctionNode = {}));
+var ParameterNode;
+(function (ParameterNode) {
+    function create(startToken, paramCategory) {
+        const node = {
+            start: startToken.start,
+            length: startToken.length,
+            nodeType: 41 /* Parameter */,
+            id: _nextNodeId++,
+            category: paramCategory,
+        };
+        return node;
+    }
+    ParameterNode.create = create;
+})(ParameterNode = exports.ParameterNode || (exports.ParameterNode = {}));
+var ClassNode;
+(function (ClassNode) {
+    function create(classToken, name, suite) {
+        const node = {
+            start: classToken.start,
+            length: classToken.length,
+            nodeType: 10 /* Class */,
+            id: _nextNodeId++,
+            decorators: [],
+            name,
+            arguments: [],
+            suite,
+        };
+        name.parent = node;
+        suite.parent = node;
+        extendRange(node, suite);
+        return node;
+    }
+    ClassNode.create = create;
+    // This variant is used to create a dummy class
+    // when the parser encounters decorators with no
+    // function or class declaration.
+    function createDummyForDecorators(decorators) {
+        const node = {
+            start: decorators[0].start,
+            length: 0,
+            nodeType: 10 /* Class */,
+            id: _nextNodeId++,
+            decorators,
+            name: {
+                start: decorators[0].start,
+                length: 0,
+                id: 0,
+                nodeType: 38 /* Name */,
+                token: {
+                    type: 7 /* Identifier */,
+                    start: 0,
+                    length: 0,
+                    comments: [],
+                    value: '',
+                },
+                value: '',
+            },
+            arguments: [],
+            suite: {
+                start: decorators[0].start,
+                length: 0,
+                id: 0,
+                nodeType: 50 /* Suite */,
+                statements: [],
+            },
+        };
+        decorators.forEach((decorator) => {
+            decorator.parent = node;
+            extendRange(node, decorator);
+        });
+        node.name.parent = node;
+        node.suite.parent = node;
+        return node;
+    }
+    ClassNode.createDummyForDecorators = createDummyForDecorators;
+})(ClassNode = exports.ClassNode || (exports.ClassNode = {}));
+var WithNode;
+(function (WithNode) {
+    function create(withToken, suite) {
+        const node = {
+            start: withToken.start,
+            length: withToken.length,
+            nodeType: 58 /* With */,
+            id: _nextNodeId++,
+            withItems: [],
+            suite,
+        };
+        suite.parent = node;
+        extendRange(node, suite);
+        return node;
+    }
+    WithNode.create = create;
+})(WithNode = exports.WithNode || (exports.WithNode = {}));
+var WithItemNode;
+(function (WithItemNode) {
+    function create(expression) {
+        const node = {
+            start: expression.start,
+            length: expression.length,
+            nodeType: 59 /* WithItem */,
+            id: _nextNodeId++,
+            expression,
+        };
+        expression.parent = node;
+        return node;
+    }
+    WithItemNode.create = create;
+})(WithItemNode = exports.WithItemNode || (exports.WithItemNode = {}));
+var DecoratorNode;
+(function (DecoratorNode) {
+    function create(atToken, expression) {
+        const node = {
+            start: atToken.start,
+            length: atToken.length,
+            nodeType: 13 /* Decorator */,
+            id: _nextNodeId++,
+            expression,
+        };
+        expression.parent = node;
+        extendRange(node, expression);
+        return node;
+    }
+    DecoratorNode.create = create;
+})(DecoratorNode = exports.DecoratorNode || (exports.DecoratorNode = {}));
+var StatementListNode;
+(function (StatementListNode) {
+    function create(atToken) {
+        const node = {
+            start: atToken.start,
+            length: atToken.length,
+            nodeType: 47 /* StatementList */,
+            id: _nextNodeId++,
+            statements: [],
+        };
+        return node;
+    }
+    StatementListNode.create = create;
+})(StatementListNode = exports.StatementListNode || (exports.StatementListNode = {}));
+function isExpressionNode(node) {
+    switch (node.nodeType) {
+        case 0 /* Error */:
+        case 55 /* UnaryOperation */:
+        case 7 /* BinaryOperation */:
+        case 4 /* AssignmentExpression */:
+        case 54 /* TypeAnnotation */:
+        case 6 /* Await */:
+        case 51 /* Ternary */:
+        case 56 /* Unpack */:
+        case 52 /* Tuple */:
+        case 9 /* Call */:
+        case 32 /* ListComprehension */:
+        case 24 /* Index */:
+        case 46 /* Slice */:
+        case 60 /* Yield */:
+        case 61 /* YieldFrom */:
+        case 35 /* MemberAccess */:
+        case 30 /* Lambda */:
+        case 38 /* Name */:
+        case 11 /* Constant */:
+        case 18 /* Ellipsis */:
+        case 40 /* Number */:
+        case 49 /* String */:
+        case 27 /* FormatString */:
+        case 48 /* StringList */:
+        case 15 /* Dictionary */:
+        case 16 /* DictionaryExpandEntry */:
+        case 31 /* List */:
+        case 45 /* Set */:
+            return true;
+        default:
+            return false;
+    }
+}
+exports.isExpressionNode = isExpressionNode;
+var ErrorNode;
+(function (ErrorNode) {
+    function create(initialRange, category, child, decorators) {
+        const node = {
+            start: initialRange.start,
+            length: initialRange.length,
+            nodeType: 0 /* Error */,
+            id: _nextNodeId++,
+            category,
+            child,
+            decorators,
+        };
+        if (child) {
+            child.parent = node;
+            extendRange(node, child);
+        }
+        if (decorators) {
+            decorators.forEach((decorator) => {
+                decorator.parent = node;
+            });
+            if (decorators.length > 0) {
+                extendRange(node, decorators[0]);
+            }
+        }
+        return node;
+    }
+    ErrorNode.create = create;
+})(ErrorNode = exports.ErrorNode || (exports.ErrorNode = {}));
+var UnaryOperationNode;
+(function (UnaryOperationNode) {
+    function create(operatorToken, expression, operator) {
+        var _a;
+        const node = {
+            start: operatorToken.start,
+            length: operatorToken.length,
+            nodeType: 55 /* UnaryOperation */,
+            id: _nextNodeId++,
+            operator,
+            operatorToken,
+            expression,
+        };
+        expression.parent = node;
+        node.maxChildDepth = 1 + ((_a = expression.maxChildDepth) !== null && _a !== void 0 ? _a : 0);
+        extendRange(node, expression);
+        return node;
+    }
+    UnaryOperationNode.create = create;
+})(UnaryOperationNode = exports.UnaryOperationNode || (exports.UnaryOperationNode = {}));
+var BinaryOperationNode;
+(function (BinaryOperationNode) {
+    function create(leftExpression, rightExpression, operatorToken, operator) {
+        var _a, _b;
+        const node = {
+            start: leftExpression.start,
+            length: leftExpression.length,
+            nodeType: 7 /* BinaryOperation */,
+            id: _nextNodeId++,
+            leftExpression,
+            operatorToken,
+            operator,
+            rightExpression,
+        };
+        leftExpression.parent = node;
+        rightExpression.parent = node;
+        node.maxChildDepth = 1 + Math.max((_a = leftExpression.maxChildDepth) !== null && _a !== void 0 ? _a : 0, (_b = rightExpression.maxChildDepth) !== null && _b !== void 0 ? _b : 0);
+        extendRange(node, rightExpression);
+        return node;
+    }
+    BinaryOperationNode.create = create;
+})(BinaryOperationNode = exports.BinaryOperationNode || (exports.BinaryOperationNode = {}));
+var AssignmentExpressionNode;
+(function (AssignmentExpressionNode) {
+    function create(name, rightExpression) {
+        const node = {
+            start: name.start,
+            length: name.length,
+            nodeType: 4 /* AssignmentExpression */,
+            id: _nextNodeId++,
+            name,
+            rightExpression,
+        };
+        name.parent = node;
+        rightExpression.parent = node;
+        extendRange(node, rightExpression);
+        return node;
+    }
+    AssignmentExpressionNode.create = create;
+})(AssignmentExpressionNode = exports.AssignmentExpressionNode || (exports.AssignmentExpressionNode = {}));
+var AssignmentNode;
+(function (AssignmentNode) {
+    function create(leftExpression, rightExpression) {
+        const node = {
+            start: leftExpression.start,
+            length: leftExpression.length,
+            nodeType: 3 /* Assignment */,
+            id: _nextNodeId++,
+            leftExpression,
+            rightExpression,
+        };
+        leftExpression.parent = node;
+        rightExpression.parent = node;
+        extendRange(node, rightExpression);
+        return node;
+    }
+    AssignmentNode.create = create;
+})(AssignmentNode = exports.AssignmentNode || (exports.AssignmentNode = {}));
+var TypeAnnotationNode;
+(function (TypeAnnotationNode) {
+    function create(valueExpression, typeAnnotation) {
+        const node = {
+            start: valueExpression.start,
+            length: valueExpression.length,
+            nodeType: 54 /* TypeAnnotation */,
+            id: _nextNodeId++,
+            valueExpression,
+            typeAnnotation,
+        };
+        valueExpression.parent = node;
+        typeAnnotation.parent = node;
+        extendRange(node, typeAnnotation);
+        return node;
+    }
+    TypeAnnotationNode.create = create;
+})(TypeAnnotationNode = exports.TypeAnnotationNode || (exports.TypeAnnotationNode = {}));
+var FunctionAnnotationNode;
+(function (FunctionAnnotationNode) {
+    function create(openParenToken, isParamListEllipsis, paramTypeAnnotations, returnTypeAnnotation) {
+        const node = {
+            start: openParenToken.start,
+            length: openParenToken.length,
+            nodeType: 62 /* FunctionAnnotation */,
+            id: _nextNodeId++,
+            isParamListEllipsis,
+            paramTypeAnnotations,
+            returnTypeAnnotation,
+        };
+        paramTypeAnnotations.forEach((p) => {
+            p.parent = node;
+        });
+        returnTypeAnnotation.parent = node;
+        extendRange(node, returnTypeAnnotation);
+        return node;
+    }
+    FunctionAnnotationNode.create = create;
+})(FunctionAnnotationNode = exports.FunctionAnnotationNode || (exports.FunctionAnnotationNode = {}));
+var AugmentedAssignmentNode;
+(function (AugmentedAssignmentNode) {
+    function create(leftExpression, rightExpression, operator, destExpression) {
+        const node = {
+            start: leftExpression.start,
+            length: leftExpression.length,
+            nodeType: 5 /* AugmentedAssignment */,
+            id: _nextNodeId++,
+            leftExpression,
+            operator,
+            rightExpression,
+            destExpression,
+        };
+        leftExpression.parent = node;
+        rightExpression.parent = node;
+        destExpression.parent = node;
+        extendRange(node, rightExpression);
+        return node;
+    }
+    AugmentedAssignmentNode.create = create;
+})(AugmentedAssignmentNode = exports.AugmentedAssignmentNode || (exports.AugmentedAssignmentNode = {}));
+var AwaitNode;
+(function (AwaitNode) {
+    function create(awaitToken, expression) {
+        const node = {
+            start: awaitToken.start,
+            length: awaitToken.length,
+            nodeType: 6 /* Await */,
+            id: _nextNodeId++,
+            expression,
+        };
+        expression.parent = node;
+        extendRange(node, expression);
+        return node;
+    }
+    AwaitNode.create = create;
+})(AwaitNode = exports.AwaitNode || (exports.AwaitNode = {}));
+var TernaryNode;
+(function (TernaryNode) {
+    function create(ifExpression, testExpression, elseExpression) {
+        const node = {
+            start: ifExpression.start,
+            length: ifExpression.length,
+            nodeType: 51 /* Ternary */,
+            id: _nextNodeId++,
+            ifExpression,
+            testExpression,
+            elseExpression,
+        };
+        ifExpression.parent = node;
+        testExpression.parent = node;
+        elseExpression.parent = node;
+        extendRange(node, elseExpression);
+        return node;
+    }
+    TernaryNode.create = create;
+})(TernaryNode = exports.TernaryNode || (exports.TernaryNode = {}));
+var UnpackNode;
+(function (UnpackNode) {
+    function create(starToken, expression) {
+        const node = {
+            start: starToken.start,
+            length: starToken.length,
+            nodeType: 56 /* Unpack */,
+            id: _nextNodeId++,
+            expression,
+        };
+        expression.parent = node;
+        extendRange(node, expression);
+        return node;
+    }
+    UnpackNode.create = create;
+})(UnpackNode = exports.UnpackNode || (exports.UnpackNode = {}));
+var TupleNode;
+(function (TupleNode) {
+    function create(range, enclosedInParens) {
+        const node = {
+            start: range.start,
+            length: range.length,
+            nodeType: 52 /* Tuple */,
+            id: _nextNodeId++,
+            expressions: [],
+            enclosedInParens,
+        };
+        return node;
+    }
+    TupleNode.create = create;
+})(TupleNode = exports.TupleNode || (exports.TupleNode = {}));
+var CallNode;
+(function (CallNode) {
+    function create(leftExpression, argList, trailingComma) {
+        var _a;
+        const node = {
+            start: leftExpression.start,
+            length: leftExpression.length,
+            nodeType: 9 /* Call */,
+            id: _nextNodeId++,
+            leftExpression,
+            arguments: argList,
+            trailingComma,
+        };
+        leftExpression.parent = node;
+        node.maxChildDepth = 1 + ((_a = leftExpression.maxChildDepth) !== null && _a !== void 0 ? _a : 0);
+        if (argList.length > 0) {
+            argList.forEach((arg) => {
+                arg.parent = node;
+            });
+            extendRange(node, argList[argList.length - 1]);
+        }
+        return node;
+    }
+    CallNode.create = create;
+})(CallNode = exports.CallNode || (exports.CallNode = {}));
+var ListComprehensionNode;
+(function (ListComprehensionNode) {
+    function create(expression) {
+        const node = {
+            start: expression.start,
+            length: expression.length,
+            nodeType: 32 /* ListComprehension */,
+            id: _nextNodeId++,
+            expression,
+            forIfNodes: [],
+        };
+        expression.parent = node;
+        return node;
+    }
+    ListComprehensionNode.create = create;
+})(ListComprehensionNode = exports.ListComprehensionNode || (exports.ListComprehensionNode = {}));
+var IndexNode;
+(function (IndexNode) {
+    function create(baseExpression, items, trailingComma, closeBracketToken) {
+        var _a;
+        const node = {
+            start: baseExpression.start,
+            length: baseExpression.length,
+            nodeType: 24 /* Index */,
+            id: _nextNodeId++,
+            baseExpression,
+            items,
+            trailingComma,
+        };
+        baseExpression.parent = node;
+        items.forEach((item) => {
+            item.parent = node;
+        });
+        extendRange(node, closeBracketToken);
+        node.maxChildDepth = 1 + ((_a = baseExpression.maxChildDepth) !== null && _a !== void 0 ? _a : 0);
+        return node;
+    }
+    IndexNode.create = create;
+})(IndexNode = exports.IndexNode || (exports.IndexNode = {}));
+var SliceNode;
+(function (SliceNode) {
+    function create(range) {
+        const node = {
+            start: range.start,
+            length: range.length,
+            nodeType: 46 /* Slice */,
+            id: _nextNodeId++,
+        };
+        return node;
+    }
+    SliceNode.create = create;
+})(SliceNode = exports.SliceNode || (exports.SliceNode = {}));
+var YieldNode;
+(function (YieldNode) {
+    function create(yieldToken, expression) {
+        const node = {
+            start: yieldToken.start,
+            length: yieldToken.length,
+            nodeType: 60 /* Yield */,
+            id: _nextNodeId++,
+            expression,
+        };
+        if (expression) {
+            expression.parent = node;
+            extendRange(node, expression);
+        }
+        return node;
+    }
+    YieldNode.create = create;
+})(YieldNode = exports.YieldNode || (exports.YieldNode = {}));
+var YieldFromNode;
+(function (YieldFromNode) {
+    function create(yieldToken, expression) {
+        const node = {
+            start: yieldToken.start,
+            length: yieldToken.length,
+            nodeType: 61 /* YieldFrom */,
+            id: _nextNodeId++,
+            expression,
+        };
+        expression.parent = node;
+        extendRange(node, expression);
+        return node;
+    }
+    YieldFromNode.create = create;
+})(YieldFromNode = exports.YieldFromNode || (exports.YieldFromNode = {}));
+var MemberAccessNode;
+(function (MemberAccessNode) {
+    function create(leftExpression, memberName) {
+        var _a;
+        const node = {
+            start: leftExpression.start,
+            length: leftExpression.length,
+            nodeType: 35 /* MemberAccess */,
+            id: _nextNodeId++,
+            leftExpression,
+            memberName,
+        };
+        leftExpression.parent = node;
+        memberName.parent = node;
+        extendRange(node, memberName);
+        node.maxChildDepth = 1 + ((_a = leftExpression.maxChildDepth) !== null && _a !== void 0 ? _a : 0);
+        return node;
+    }
+    MemberAccessNode.create = create;
+})(MemberAccessNode = exports.MemberAccessNode || (exports.MemberAccessNode = {}));
+var LambdaNode;
+(function (LambdaNode) {
+    function create(lambdaToken, expression) {
+        const node = {
+            start: lambdaToken.start,
+            length: lambdaToken.length,
+            nodeType: 30 /* Lambda */,
+            id: _nextNodeId++,
+            parameters: [],
+            expression,
+        };
+        expression.parent = node;
+        extendRange(node, expression);
+        return node;
+    }
+    LambdaNode.create = create;
+})(LambdaNode = exports.LambdaNode || (exports.LambdaNode = {}));
+var NameNode;
+(function (NameNode) {
+    function create(nameToken) {
+        const node = {
+            start: nameToken.start,
+            length: nameToken.length,
+            nodeType: 38 /* Name */,
+            id: _nextNodeId++,
+            token: nameToken,
+            value: nameToken.value,
+        };
+        return node;
+    }
+    NameNode.create = create;
+})(NameNode = exports.NameNode || (exports.NameNode = {}));
+var ConstantNode;
+(function (ConstantNode) {
+    function create(token) {
+        const node = {
+            start: token.start,
+            length: token.length,
+            nodeType: 11 /* Constant */,
+            id: _nextNodeId++,
+            constType: token.keywordType,
+        };
+        return node;
+    }
+    ConstantNode.create = create;
+})(ConstantNode = exports.ConstantNode || (exports.ConstantNode = {}));
+var EllipsisNode;
+(function (EllipsisNode) {
+    function create(range) {
+        const node = {
+            start: range.start,
+            length: range.length,
+            nodeType: 18 /* Ellipsis */,
+            id: _nextNodeId++,
+        };
+        return node;
+    }
+    EllipsisNode.create = create;
+})(EllipsisNode = exports.EllipsisNode || (exports.EllipsisNode = {}));
+var NumberNode;
+(function (NumberNode) {
+    function create(token) {
+        const node = {
+            start: token.start,
+            length: token.length,
+            nodeType: 40 /* Number */,
+            id: _nextNodeId++,
+            value: token.value,
+            isInteger: token.isInteger,
+            isImaginary: token.isImaginary,
+        };
+        return node;
+    }
+    NumberNode.create = create;
+})(NumberNode = exports.NumberNode || (exports.NumberNode = {}));
+var StringNode;
+(function (StringNode) {
+    function create(token, unescapedValue, hasUnescapeErrors) {
+        const node = {
+            start: token.start,
+            length: token.length,
+            nodeType: 49 /* String */,
+            id: _nextNodeId++,
+            token,
+            value: unescapedValue,
+            hasUnescapeErrors,
+        };
+        return node;
+    }
+    StringNode.create = create;
+})(StringNode = exports.StringNode || (exports.StringNode = {}));
+var FormatStringNode;
+(function (FormatStringNode) {
+    function create(token, unescapedValue, hasUnescapeErrors, expressions) {
+        const node = {
+            start: token.start,
+            length: token.length,
+            nodeType: 27 /* FormatString */,
+            id: _nextNodeId++,
+            token,
+            value: unescapedValue,
+            hasUnescapeErrors,
+            expressions,
+        };
+        expressions.forEach((expr) => {
+            expr.parent = node;
+        });
+        return node;
+    }
+    FormatStringNode.create = create;
+})(FormatStringNode = exports.FormatStringNode || (exports.FormatStringNode = {}));
+var StringListNode;
+(function (StringListNode) {
+    function create(strings) {
+        const node = {
+            start: strings[0].start,
+            length: strings[0].length,
+            nodeType: 48 /* StringList */,
+            id: _nextNodeId++,
+            strings,
+        };
+        if (strings.length > 0) {
+            strings.forEach((str) => {
+                str.parent = node;
+            });
+            extendRange(node, strings[strings.length - 1]);
+        }
+        return node;
+    }
+    StringListNode.create = create;
+})(StringListNode = exports.StringListNode || (exports.StringListNode = {}));
+var DictionaryNode;
+(function (DictionaryNode) {
+    function create(range) {
+        const node = {
+            start: range.start,
+            length: range.length,
+            nodeType: 15 /* Dictionary */,
+            id: _nextNodeId++,
+            entries: [],
+        };
+        return node;
+    }
+    DictionaryNode.create = create;
+})(DictionaryNode = exports.DictionaryNode || (exports.DictionaryNode = {}));
+var DictionaryKeyEntryNode;
+(function (DictionaryKeyEntryNode) {
+    function create(keyExpression, valueExpression) {
+        const node = {
+            start: keyExpression.start,
+            length: keyExpression.length,
+            nodeType: 17 /* DictionaryKeyEntry */,
+            id: _nextNodeId++,
+            keyExpression,
+            valueExpression,
+        };
+        keyExpression.parent = node;
+        valueExpression.parent = node;
+        extendRange(node, valueExpression);
+        return node;
+    }
+    DictionaryKeyEntryNode.create = create;
+})(DictionaryKeyEntryNode = exports.DictionaryKeyEntryNode || (exports.DictionaryKeyEntryNode = {}));
+var DictionaryExpandEntryNode;
+(function (DictionaryExpandEntryNode) {
+    function create(expandExpression) {
+        const node = {
+            start: expandExpression.start,
+            length: expandExpression.length,
+            nodeType: 16 /* DictionaryExpandEntry */,
+            id: _nextNodeId++,
+            expandExpression,
+        };
+        expandExpression.parent = node;
+        return node;
+    }
+    DictionaryExpandEntryNode.create = create;
+})(DictionaryExpandEntryNode = exports.DictionaryExpandEntryNode || (exports.DictionaryExpandEntryNode = {}));
+var SetNode;
+(function (SetNode) {
+    function create(range) {
+        const node = {
+            start: range.start,
+            length: range.length,
+            nodeType: 45 /* Set */,
+            id: _nextNodeId++,
+            entries: [],
+        };
+        return node;
+    }
+    SetNode.create = create;
+})(SetNode = exports.SetNode || (exports.SetNode = {}));
+var ListNode;
+(function (ListNode) {
+    function create(range) {
+        const node = {
+            start: range.start,
+            length: range.length,
+            nodeType: 31 /* List */,
+            id: _nextNodeId++,
+            entries: [],
+        };
+        return node;
+    }
+    ListNode.create = create;
+})(ListNode = exports.ListNode || (exports.ListNode = {}));
+var ArgumentNode;
+(function (ArgumentNode) {
+    function create(startToken, valueExpression, argCategory) {
+        const node = {
+            start: startToken ? startToken.start : valueExpression.start,
+            length: startToken ? startToken.length : valueExpression.length,
+            nodeType: 1 /* Argument */,
+            id: _nextNodeId++,
+            valueExpression,
+            argumentCategory: argCategory,
+        };
+        valueExpression.parent = node;
+        extendRange(node, valueExpression);
+        return node;
+    }
+    ArgumentNode.create = create;
+})(ArgumentNode = exports.ArgumentNode || (exports.ArgumentNode = {}));
+var DelNode;
+(function (DelNode) {
+    function create(delToken) {
+        const node = {
+            start: delToken.start,
+            length: delToken.length,
+            nodeType: 14 /* Del */,
+            id: _nextNodeId++,
+            expressions: [],
+        };
+        return node;
+    }
+    DelNode.create = create;
+})(DelNode = exports.DelNode || (exports.DelNode = {}));
+var PassNode;
+(function (PassNode) {
+    function create(passToken) {
+        const node = {
+            start: passToken.start,
+            length: passToken.length,
+            nodeType: 42 /* Pass */,
+            id: _nextNodeId++,
+        };
+        return node;
+    }
+    PassNode.create = create;
+})(PassNode = exports.PassNode || (exports.PassNode = {}));
+var ImportNode;
+(function (ImportNode) {
+    function create(passToken) {
+        const node = {
+            start: passToken.start,
+            length: passToken.length,
+            nodeType: 20 /* Import */,
+            id: _nextNodeId++,
+            list: [],
+        };
+        return node;
+    }
+    ImportNode.create = create;
+})(ImportNode = exports.ImportNode || (exports.ImportNode = {}));
+var ModuleNameNode;
+(function (ModuleNameNode) {
+    function create(range) {
+        const node = {
+            start: range.start,
+            length: range.length,
+            nodeType: 37 /* ModuleName */,
+            id: _nextNodeId++,
+            leadingDots: 0,
+            nameParts: [],
+        };
+        return node;
+    }
+    ModuleNameNode.create = create;
+})(ModuleNameNode = exports.ModuleNameNode || (exports.ModuleNameNode = {}));
+var ImportAsNode;
+(function (ImportAsNode) {
+    function create(module) {
+        const node = {
+            start: module.start,
+            length: module.length,
+            nodeType: 21 /* ImportAs */,
+            id: _nextNodeId++,
+            module,
+        };
+        module.parent = node;
+        return node;
+    }
+    ImportAsNode.create = create;
+})(ImportAsNode = exports.ImportAsNode || (exports.ImportAsNode = {}));
+var ImportFromNode;
+(function (ImportFromNode) {
+    function create(fromToken, module) {
+        const node = {
+            start: fromToken.start,
+            length: fromToken.length,
+            nodeType: 22 /* ImportFrom */,
+            id: _nextNodeId++,
+            module,
+            imports: [],
+            isWildcardImport: false,
+            usesParens: false,
+        };
+        module.parent = node;
+        extendRange(node, module);
+        return node;
+    }
+    ImportFromNode.create = create;
+})(ImportFromNode = exports.ImportFromNode || (exports.ImportFromNode = {}));
+var ImportFromAsNode;
+(function (ImportFromAsNode) {
+    function create(name) {
+        const node = {
+            start: name.start,
+            length: name.length,
+            nodeType: 23 /* ImportFromAs */,
+            id: _nextNodeId++,
+            name,
+        };
+        name.parent = node;
+        return node;
+    }
+    ImportFromAsNode.create = create;
+})(ImportFromAsNode = exports.ImportFromAsNode || (exports.ImportFromAsNode = {}));
+var GlobalNode;
+(function (GlobalNode) {
+    function create(range) {
+        const node = {
+            start: range.start,
+            length: range.length,
+            nodeType: 29 /* Global */,
+            id: _nextNodeId++,
+            nameList: [],
+        };
+        return node;
+    }
+    GlobalNode.create = create;
+})(GlobalNode = exports.GlobalNode || (exports.GlobalNode = {}));
+var NonlocalNode;
+(function (NonlocalNode) {
+    function create(range) {
+        const node = {
+            start: range.start,
+            length: range.length,
+            nodeType: 39 /* Nonlocal */,
+            id: _nextNodeId++,
+            nameList: [],
+        };
+        return node;
+    }
+    NonlocalNode.create = create;
+})(NonlocalNode = exports.NonlocalNode || (exports.NonlocalNode = {}));
+var AssertNode;
+(function (AssertNode) {
+    function create(assertToken, testExpression) {
+        const node = {
+            start: assertToken.start,
+            length: assertToken.length,
+            nodeType: 2 /* Assert */,
+            id: _nextNodeId++,
+            testExpression,
+        };
+        testExpression.parent = node;
+        extendRange(node, testExpression);
+        return node;
+    }
+    AssertNode.create = create;
+})(AssertNode = exports.AssertNode || (exports.AssertNode = {}));
+var BreakNode;
+(function (BreakNode) {
+    function create(range) {
+        const node = {
+            start: range.start,
+            length: range.length,
+            nodeType: 8 /* Break */,
+            id: _nextNodeId++,
+        };
+        return node;
+    }
+    BreakNode.create = create;
+})(BreakNode = exports.BreakNode || (exports.BreakNode = {}));
+var ContinueNode;
+(function (ContinueNode) {
+    function create(range) {
+        const node = {
+            start: range.start,
+            length: range.length,
+            nodeType: 12 /* Continue */,
+            id: _nextNodeId++,
+        };
+        return node;
+    }
+    ContinueNode.create = create;
+})(ContinueNode = exports.ContinueNode || (exports.ContinueNode = {}));
+var ReturnNode;
+(function (ReturnNode) {
+    function create(range) {
+        const node = {
+            start: range.start,
+            length: range.length,
+            nodeType: 44 /* Return */,
+            id: _nextNodeId++,
+        };
+        return node;
+    }
+    ReturnNode.create = create;
+})(ReturnNode = exports.ReturnNode || (exports.ReturnNode = {}));
+var RaiseNode;
+(function (RaiseNode) {
+    function create(range) {
+        const node = {
+            start: range.start,
+            length: range.length,
+            nodeType: 43 /* Raise */,
+            id: _nextNodeId++,
+        };
+        return node;
+    }
+    RaiseNode.create = create;
+})(RaiseNode = exports.RaiseNode || (exports.RaiseNode = {}));
+var MatchNode;
+(function (MatchNode) {
+    function create(matchToken, subjectExpression) {
+        const node = {
+            start: matchToken.start,
+            length: matchToken.length,
+            nodeType: 63 /* Match */,
+            id: _nextNodeId++,
+            subjectExpression,
+            cases: [],
+        };
+        subjectExpression.parent = node;
+        extendRange(node, subjectExpression);
+        return node;
+    }
+    MatchNode.create = create;
+})(MatchNode = exports.MatchNode || (exports.MatchNode = {}));
+var CaseNode;
+(function (CaseNode) {
+    function create(caseToken, pattern, isIrrefutable, guardExpression, suite) {
+        const node = {
+            start: caseToken.start,
+            length: caseToken.length,
+            nodeType: 64 /* Case */,
+            id: _nextNodeId++,
+            pattern,
+            isIrrefutable,
+            guardExpression,
+            suite,
+        };
+        extendRange(node, suite);
+        pattern.parent = node;
+        suite.parent = node;
+        if (guardExpression) {
+            guardExpression.parent = node;
+        }
+        return node;
+    }
+    CaseNode.create = create;
+})(CaseNode = exports.CaseNode || (exports.CaseNode = {}));
+var PatternSequenceNode;
+(function (PatternSequenceNode) {
+    function create(firstToken, entries) {
+        const starEntryIndex = entries.findIndex((entry) => entry.orPatterns.length === 1 &&
+            entry.orPatterns[0].nodeType === 69 /* PatternCapture */ &&
+            entry.orPatterns[0].isStar);
+        const node = {
+            start: firstToken.start,
+            length: firstToken.length,
+            nodeType: 65 /* PatternSequence */,
+            id: _nextNodeId++,
+            entries,
+            starEntryIndex: starEntryIndex >= 0 ? starEntryIndex : undefined,
+        };
+        if (entries.length > 0) {
+            extendRange(node, entries[entries.length - 1]);
+        }
+        entries.forEach((entry) => {
+            entry.parent = node;
+        });
+        return node;
+    }
+    PatternSequenceNode.create = create;
+})(PatternSequenceNode = exports.PatternSequenceNode || (exports.PatternSequenceNode = {}));
+var PatternAsNode;
+(function (PatternAsNode) {
+    function create(orPatterns, target) {
+        const node = {
+            start: orPatterns[0].start,
+            length: orPatterns[0].length,
+            nodeType: 66 /* PatternAs */,
+            id: _nextNodeId++,
+            orPatterns,
+            target,
+        };
+        if (orPatterns.length > 1) {
+            extendRange(node, orPatterns[orPatterns.length - 1]);
+        }
+        orPatterns.forEach((pattern) => {
+            pattern.parent = node;
+        });
+        if (target) {
+            extendRange(node, target);
+            target.parent = node;
+        }
+        return node;
+    }
+    PatternAsNode.create = create;
+})(PatternAsNode = exports.PatternAsNode || (exports.PatternAsNode = {}));
+var PatternLiteralNode;
+(function (PatternLiteralNode) {
+    function create(expression) {
+        const node = {
+            start: expression.start,
+            length: expression.length,
+            nodeType: 67 /* PatternLiteral */,
+            id: _nextNodeId++,
+            expression,
+        };
+        expression.parent = node;
+        return node;
+    }
+    PatternLiteralNode.create = create;
+})(PatternLiteralNode = exports.PatternLiteralNode || (exports.PatternLiteralNode = {}));
+var PatternClassNode;
+(function (PatternClassNode) {
+    function create(className, args) {
+        const node = {
+            start: className.start,
+            length: className.length,
+            nodeType: 68 /* PatternClass */,
+            id: _nextNodeId++,
+            className,
+            arguments: args,
+        };
+        className.parent = node;
+        args.forEach((arg) => {
+            arg.parent = node;
+        });
+        if (args.length > 0) {
+            extendRange(node, args[args.length - 1]);
+        }
+        return node;
+    }
+    PatternClassNode.create = create;
+})(PatternClassNode = exports.PatternClassNode || (exports.PatternClassNode = {}));
+var PatternClassArgumentNode;
+(function (PatternClassArgumentNode) {
+    function create(pattern, name) {
+        const node = {
+            start: pattern.start,
+            length: pattern.length,
+            nodeType: 74 /* PatternClassArgument */,
+            id: _nextNodeId++,
+            pattern,
+            name,
+        };
+        pattern.parent = node;
+        if (name) {
+            extendRange(node, name);
+            name.parent = node;
+        }
+        return node;
+    }
+    PatternClassArgumentNode.create = create;
+})(PatternClassArgumentNode = exports.PatternClassArgumentNode || (exports.PatternClassArgumentNode = {}));
+var PatternCaptureNode;
+(function (PatternCaptureNode) {
+    function create(target, starToken) {
+        const node = {
+            start: target.start,
+            length: target.length,
+            nodeType: 69 /* PatternCapture */,
+            id: _nextNodeId++,
+            target,
+            isStar: starToken !== undefined,
+            isWildcard: target.value === '_',
+        };
+        target.parent = node;
+        if (starToken) {
+            extendRange(node, starToken);
+        }
+        return node;
+    }
+    PatternCaptureNode.create = create;
+})(PatternCaptureNode = exports.PatternCaptureNode || (exports.PatternCaptureNode = {}));
+var PatternMappingNode;
+(function (PatternMappingNode) {
+    function create(startToken, entries) {
+        const node = {
+            start: startToken.start,
+            length: startToken.length,
+            nodeType: 70 /* PatternMapping */,
+            id: _nextNodeId++,
+            entries,
+        };
+        if (entries.length > 0) {
+            extendRange(node, entries[entries.length - 1]);
+        }
+        entries.forEach((entry) => {
+            entry.parent = node;
+        });
+        return node;
+    }
+    PatternMappingNode.create = create;
+})(PatternMappingNode = exports.PatternMappingNode || (exports.PatternMappingNode = {}));
+var PatternMappingKeyEntryNode;
+(function (PatternMappingKeyEntryNode) {
+    function create(keyPattern, valuePattern) {
+        const node = {
+            start: keyPattern.start,
+            length: keyPattern.length,
+            nodeType: 71 /* PatternMappingKeyEntry */,
+            id: _nextNodeId++,
+            keyPattern,
+            valuePattern,
+        };
+        keyPattern.parent = node;
+        valuePattern.parent = node;
+        extendRange(node, valuePattern);
+        return node;
+    }
+    PatternMappingKeyEntryNode.create = create;
+})(PatternMappingKeyEntryNode = exports.PatternMappingKeyEntryNode || (exports.PatternMappingKeyEntryNode = {}));
+var PatternMappingExpandEntryNode;
+(function (PatternMappingExpandEntryNode) {
+    function create(starStarToken, target) {
+        const node = {
+            start: starStarToken.start,
+            length: starStarToken.length,
+            nodeType: 72 /* PatternMappingExpandEntry */,
+            id: _nextNodeId++,
+            target,
+        };
+        target.parent = node;
+        extendRange(node, target);
+        return node;
+    }
+    PatternMappingExpandEntryNode.create = create;
+})(PatternMappingExpandEntryNode = exports.PatternMappingExpandEntryNode || (exports.PatternMappingExpandEntryNode = {}));
+var PatternValueNode;
+(function (PatternValueNode) {
+    function create(expression) {
+        const node = {
+            start: expression.start,
+            length: expression.length,
+            nodeType: 73 /* PatternValue */,
+            id: _nextNodeId++,
+            expression,
+        };
+        expression.parent = node;
+        return node;
+    }
+    PatternValueNode.create = create;
+})(PatternValueNode = exports.PatternValueNode || (exports.PatternValueNode = {}));
+//# sourceMappingURL=parseNodes.js.map