@zzzen/pyright-internal 1.2.0-dev.20240630 → 1.2.0-dev.20240714

package/dist/parser/parseNodes.js

@@ -9,7 +9,7 @@
  * syntax tree (AST).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NumberNode = exports.EllipsisNode = exports.ConstantNode = exports.NameNode = exports.LambdaNode = exports.MemberAccessNode = exports.YieldFromNode = exports.YieldNode = exports.SliceNode = exports.IndexNode = exports.ComprehensionNode = exports.CallNode = exports.TupleNode = exports.UnpackNode = exports.TernaryNode = exports.AwaitNode = exports.AugmentedAssignmentNode = exports.FunctionAnnotationNode = exports.TypeAnnotationNode = exports.TypeAliasNode = exports.TypeParameterListNode = exports.TypeParameterNode = exports.TypeParameterCategory = 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.ParameterCategory = exports.FunctionNode = exports.ExceptNode = exports.TryNode = exports.ComprehensionIfNode = exports.ComprehensionForNode = exports.ForNode = exports.WhileNode = exports.IfNode = exports.SuiteNode = exports.ModuleNode = exports.extendRange = exports.getNextNodeId = exports.ErrorExpressionCategory = exports.ParseNodeType = void 0;
+exports.NumberNode = exports.EllipsisNode = exports.ConstantNode = exports.NameNode = exports.LambdaNode = exports.MemberAccessNode = exports.YieldFromNode = exports.YieldNode = exports.SliceNode = exports.IndexNode = exports.ComprehensionNode = exports.CallNode = exports.TupleNode = exports.UnpackNode = exports.TernaryNode = exports.AwaitNode = exports.AugmentedAssignmentNode = exports.FunctionAnnotationNode = exports.TypeAnnotationNode = exports.TypeAliasNode = exports.TypeParameterListNode = exports.TypeParameterNode = exports.TypeParameterKind = 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.ParameterCategory = exports.FunctionNode = exports.ExceptNode = exports.TryNode = exports.ComprehensionIfNode = exports.ComprehensionForNode = exports.ForNode = exports.WhileNode = exports.IfNode = exports.SuiteNode = exports.ModuleNode = exports.extendRange = exports.getNextNodeId = exports.ErrorExpressionCategory = exports.ParseNodeType = 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.ArgumentCategory = exports.ListNode = exports.SetNode = exports.DictionaryExpandEntryNode = exports.DictionaryKeyEntryNode = exports.DictionaryNode = exports.StringListNode = exports.FormatStringNode = exports.StringNode = void 0;
 const textRange_1 = require("../common/textRange");
 var ParseNodeType;
@@ -119,9 +119,8 @@ exports.getNextNodeId = getNextNodeId;
 function extendRange(node, newRange) {
     const extendedRange = textRange_1.TextRange.extend(node, newRange);
     // Temporarily allow writes to the range fields.
-    const mutableNode = node;
-    mutableNode.start = extendedRange.start;
-    mutableNode.length = extendedRange.length;
+    node.start = extendedRange.start;
+    node.length = extendedRange.length;
 }
 exports.extendRange = extendRange;
 var ModuleNode;
@@ -132,7 +131,9 @@ var ModuleNode;
             length: range.length,
             nodeType: 36 /* ParseNodeType.Module */,
             id: _nextNodeId++,
-            statements: [],
+            parent: undefined,
+            a: undefined,
+            d: { statements: [] },
         };
         return node;
     }
@@ -146,7 +147,12 @@ var SuiteNode;
             length: range.length,
             nodeType: 50 /* ParseNodeType.Suite */,
             id: _nextNodeId++,
-            statements: [],
+            parent: undefined,
+            a: undefined,
+            d: {
+                statements: [],
+                typeComment: undefined,
+            },
         };
         return node;
     }
@@ -154,19 +160,23 @@ var SuiteNode;
 })(SuiteNode || (exports.SuiteNode = SuiteNode = {}));
 var IfNode;
 (function (IfNode) {
-    function create(ifOrElifToken, testExpression, ifSuite, elseSuite) {
+    function create(ifOrElifToken, testExpr, ifSuite, elseSuite) {
         const node = {
             start: ifOrElifToken.start,
             length: ifOrElifToken.length,
             nodeType: 22 /* ParseNodeType.If */,
             id: _nextNodeId++,
-            testExpression,
-            ifSuite,
-            elseSuite,
+            parent: undefined,
+            a: undefined,
+            d: {
+                testExpr,
+                ifSuite: ifSuite,
+                elseSuite: elseSuite,
+            },
         };
-        testExpression.parent = node;
+        testExpr.parent = node;
         ifSuite.parent = node;
-        extendRange(node, testExpression);
+        extendRange(node, testExpr);
         extendRange(node, ifSuite);
         if (elseSuite) {
             extendRange(node, elseSuite);
@@ -178,16 +188,20 @@ var IfNode;
 })(IfNode || (exports.IfNode = IfNode = {}));
 var WhileNode;
 (function (WhileNode) {
-    function create(whileToken, testExpression, whileSuite) {
+    function create(whileToken, testExpr, whileSuite) {
         const node = {
             start: whileToken.start,
             length: whileToken.length,
             nodeType: 57 /* ParseNodeType.While */,
             id: _nextNodeId++,
-            testExpression,
-            whileSuite,
+            parent: undefined,
+            a: undefined,
+            d: {
+                testExpr,
+                whileSuite,
+            },
         };
-        testExpression.parent = node;
+        testExpr.parent = node;
         whileSuite.parent = node;
         extendRange(node, whileSuite);
         return node;
@@ -196,18 +210,22 @@ var WhileNode;
 })(WhileNode || (exports.WhileNode = WhileNode = {}));
 var ForNode;
 (function (ForNode) {
-    function create(forToken, targetExpression, iterableExpression, forSuite) {
+    function create(forToken, targetExpr, iterableExpr, forSuite) {
         const node = {
             start: forToken.start,
             length: forToken.length,
             nodeType: 29 /* ParseNodeType.For */,
             id: _nextNodeId++,
-            targetExpression,
-            iterableExpression,
-            forSuite,
+            parent: undefined,
+            a: undefined,
+            d: {
+                targetExpr,
+                iterableExpr,
+                forSuite,
+            },
         };
-        targetExpression.parent = node;
-        iterableExpression.parent = node;
+        targetExpr.parent = node;
+        iterableExpr.parent = node;
         forSuite.parent = node;
         extendRange(node, forSuite);
         return node;
@@ -216,35 +234,41 @@ var ForNode;
 })(ForNode || (exports.ForNode = ForNode = {}));
 var ComprehensionForNode;
 (function (ComprehensionForNode) {
-    function create(startToken, targetExpression, iterableExpression) {
+    function create(startToken, targetExpr, iterableExpr) {
         const node = {
             start: startToken.start,
             length: startToken.length,
             nodeType: 12 /* ParseNodeType.ComprehensionFor */,
             id: _nextNodeId++,
-            targetExpression,
-            iterableExpression,
+            parent: undefined,
+            a: undefined,
+            d: {
+                targetExpr,
+                iterableExpr,
+            },
         };
-        targetExpression.parent = node;
-        iterableExpression.parent = node;
-        extendRange(node, targetExpression);
-        extendRange(node, iterableExpression);
+        targetExpr.parent = node;
+        iterableExpr.parent = node;
+        extendRange(node, targetExpr);
+        extendRange(node, iterableExpr);
         return node;
     }
     ComprehensionForNode.create = create;
 })(ComprehensionForNode || (exports.ComprehensionForNode = ComprehensionForNode = {}));
 var ComprehensionIfNode;
 (function (ComprehensionIfNode) {
-    function create(ifToken, testExpression) {
+    function create(ifToken, testExpr) {
         const node = {
             start: ifToken.start,
             length: ifToken.length,
             nodeType: 13 /* ParseNodeType.ComprehensionIf */,
             id: _nextNodeId++,
-            testExpression,
+            parent: undefined,
+            a: undefined,
+            d: { testExpr },
         };
-        testExpression.parent = node;
-        extendRange(node, testExpression);
+        testExpr.parent = node;
+        extendRange(node, testExpr);
         return node;
     }
     ComprehensionIfNode.create = create;
@@ -257,8 +281,12 @@ var TryNode;
             length: tryToken.length,
             nodeType: 53 /* ParseNodeType.Try */,
             id: _nextNodeId++,
-            trySuite,
-            exceptClauses: [],
+            parent: undefined,
+            a: undefined,
+            d: {
+                trySuite: trySuite,
+                exceptClauses: [],
+            },
         };
         trySuite.parent = node;
         extendRange(node, trySuite);
@@ -274,8 +302,12 @@ var ExceptNode;
             length: exceptToken.length,
             nodeType: 28 /* ParseNodeType.Except */,
             id: _nextNodeId++,
-            exceptSuite,
-            isExceptGroup,
+            parent: undefined,
+            a: undefined,
+            d: {
+                exceptSuite: exceptSuite,
+                isExceptGroup: isExceptGroup,
+            },
         };
         exceptSuite.parent = node;
         extendRange(node, exceptSuite);
@@ -285,22 +317,29 @@ var ExceptNode;
 })(ExceptNode || (exports.ExceptNode = ExceptNode = {}));
 var FunctionNode;
 (function (FunctionNode) {
-    function create(defToken, name, suite, typeParameters) {
+    function create(defToken, name, suite, typeParams) {
         const node = {
             start: defToken.start,
             length: defToken.length,
             nodeType: 31 /* ParseNodeType.Function */,
             id: _nextNodeId++,
-            decorators: [],
-            name,
-            typeParameters,
-            parameters: [],
-            suite,
+            parent: undefined,
+            a: undefined,
+            d: {
+                decorators: [],
+                isAsync: false,
+                name: name,
+                typeParams,
+                params: [],
+                returnAnnotation: undefined,
+                funcAnnotationComment: undefined,
+                suite: suite,
+            },
         };
         name.parent = node;
         suite.parent = node;
-        if (typeParameters) {
-            typeParameters.parent = node;
+        if (typeParams) {
+            typeParams.parent = node;
         }
         extendRange(node, suite);
         return node;
@@ -321,7 +360,15 @@ var ParameterNode;
             length: startToken.length,
             nodeType: 41 /* ParseNodeType.Parameter */,
             id: _nextNodeId++,
-            category: paramCategory,
+            parent: undefined,
+            a: undefined,
+            d: {
+                category: paramCategory,
+                name: undefined,
+                annotation: undefined,
+                annotationComment: undefined,
+                defaultValue: undefined,
+            },
         };
         return node;
     }
@@ -329,22 +376,26 @@ var ParameterNode;
 })(ParameterNode || (exports.ParameterNode = ParameterNode = {}));
 var ClassNode;
 (function (ClassNode) {
-    function create(classToken, name, suite, typeParameters) {
+    function create(classToken, name, suite, typeParams) {
         const node = {
             start: classToken.start,
             length: classToken.length,
             nodeType: 10 /* ParseNodeType.Class */,
             id: _nextNodeId++,
-            decorators: [],
-            name,
-            typeParameters,
-            arguments: [],
-            suite,
+            parent: undefined,
+            a: undefined,
+            d: {
+                decorators: [],
+                name: name,
+                typeParams,
+                arguments: [],
+                suite: suite,
+            },
         };
         name.parent = node;
         suite.parent = node;
-        if (typeParameters) {
-            typeParameters.parent = node;
+        if (typeParams) {
+            typeParams.parent = node;
         }
         extendRange(node, suite);
         return node;
@@ -359,36 +410,47 @@ var ClassNode;
             length: 0,
             nodeType: 10 /* ParseNodeType.Class */,
             id: _nextNodeId++,
-            decorators,
-            name: {
-                start: decorators[0].start,
-                length: 0,
-                id: 0,
-                nodeType: 38 /* ParseNodeType.Name */,
-                token: {
-                    type: 7 /* TokenType.Identifier */,
-                    start: 0,
+            parent: undefined,
+            a: undefined,
+            d: {
+                decorators,
+                name: {
+                    start: decorators[0].start,
                     length: 0,
-                    comments: [],
-                    value: '',
+                    nodeType: 38 /* ParseNodeType.Name */,
+                    id: 0,
+                    parent: undefined,
+                    a: undefined,
+                    d: {
+                        token: {
+                            type: 7 /* TokenType.Identifier */,
+                            start: 0,
+                            length: 0,
+                            comments: [],
+                            value: '',
+                        },
+                        value: '',
+                    },
+                },
+                typeParams: undefined,
+                arguments: [],
+                suite: {
+                    start: decorators[0].start,
+                    length: 0,
+                    nodeType: 50 /* ParseNodeType.Suite */,
+                    id: 0,
+                    parent: undefined,
+                    a: undefined,
+                    d: { statements: [], typeComment: undefined },
                 },
-                value: '',
-            },
-            arguments: [],
-            suite: {
-                start: decorators[0].start,
-                length: 0,
-                id: 0,
-                nodeType: 50 /* ParseNodeType.Suite */,
-                statements: [],
             },
         };
         decorators.forEach((decorator) => {
             decorator.parent = node;
             extendRange(node, decorator);
         });
-        node.name.parent = node;
-        node.suite.parent = node;
+        node.d.name.parent = node;
+        node.d.suite.parent = node;
         return node;
     }
     ClassNode.createDummyForDecorators = createDummyForDecorators;
@@ -401,8 +463,12 @@ var WithNode;
             length: withToken.length,
             nodeType: 58 /* ParseNodeType.With */,
             id: _nextNodeId++,
-            withItems: [],
-            suite,
+            parent: undefined,
+            a: undefined,
+            d: {
+                withItems: [],
+                suite: suite,
+            },
         };
         suite.parent = node;
         extendRange(node, suite);
@@ -412,31 +478,35 @@ var WithNode;
 })(WithNode || (exports.WithNode = WithNode = {}));
 var WithItemNode;
 (function (WithItemNode) {
-    function create(expression) {
+    function create(expr) {
         const node = {
-            start: expression.start,
-            length: expression.length,
+            start: expr.start,
+            length: expr.length,
             nodeType: 59 /* ParseNodeType.WithItem */,
             id: _nextNodeId++,
-            expression,
+            parent: undefined,
+            a: undefined,
+            d: { expr },
         };
-        expression.parent = node;
+        expr.parent = node;
         return node;
     }
     WithItemNode.create = create;
 })(WithItemNode || (exports.WithItemNode = WithItemNode = {}));
 var DecoratorNode;
 (function (DecoratorNode) {
-    function create(atToken, expression) {
+    function create(atToken, expr) {
         const node = {
             start: atToken.start,
             length: atToken.length,
             nodeType: 16 /* ParseNodeType.Decorator */,
             id: _nextNodeId++,
-            expression,
+            parent: undefined,
+            a: undefined,
+            d: { expr },
         };
-        expression.parent = node;
-        extendRange(node, expression);
+        expr.parent = node;
+        extendRange(node, expr);
         return node;
     }
     DecoratorNode.create = create;
@@ -449,7 +519,9 @@ var StatementListNode;
             length: atToken.length,
             nodeType: 47 /* ParseNodeType.StatementList */,
             id: _nextNodeId++,
-            statements: [],
+            parent: undefined,
+            a: undefined,
+            d: { statements: [] },
         };
         return node;
     }
@@ -498,9 +570,13 @@ var ErrorNode;
             length: initialRange.length,
             nodeType: 0 /* ParseNodeType.Error */,
             id: _nextNodeId++,
-            category,
-            child,
-            decorators,
+            parent: undefined,
+            a: undefined,
+            d: {
+                category,
+                child,
+                decorators,
+            },
         };
         if (child) {
             child.parent = node;
@@ -520,111 +596,129 @@ var ErrorNode;
 })(ErrorNode || (exports.ErrorNode = ErrorNode = {}));
 var UnaryOperationNode;
 (function (UnaryOperationNode) {
-    function create(operatorToken, expression, operator) {
-        var _a;
+    function create(operatorToken, expr, operator) {
         const node = {
             start: operatorToken.start,
             length: operatorToken.length,
             nodeType: 55 /* ParseNodeType.UnaryOperation */,
             id: _nextNodeId++,
-            operator,
-            operatorToken,
-            expression,
+            parent: undefined,
+            a: undefined,
+            d: {
+                operator,
+                operatorToken,
+                expr,
+                hasParens: false,
+            },
         };
-        expression.parent = node;
-        node.maxChildDepth = 1 + ((_a = expression.maxChildDepth) !== null && _a !== void 0 ? _a : 0);
-        extendRange(node, expression);
+        expr.parent = node;
+        extendRange(node, expr);
         return node;
     }
     UnaryOperationNode.create = create;
 })(UnaryOperationNode || (exports.UnaryOperationNode = UnaryOperationNode = {}));
 var BinaryOperationNode;
 (function (BinaryOperationNode) {
-    function create(leftExpression, rightExpression, operatorToken, operator) {
-        var _a, _b;
+    function create(leftExpr, rightExpr, operatorToken, operator) {
         const node = {
-            start: leftExpression.start,
-            length: leftExpression.length,
+            start: leftExpr.start,
+            length: leftExpr.length,
             nodeType: 7 /* ParseNodeType.BinaryOperation */,
             id: _nextNodeId++,
-            leftExpression,
-            operatorToken,
-            operator,
-            rightExpression,
+            parent: undefined,
+            a: undefined,
+            d: {
+                leftExpr,
+                operatorToken,
+                operator,
+                rightExpr,
+                hasParens: false,
+            },
         };
-        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);
+        leftExpr.parent = node;
+        rightExpr.parent = node;
+        extendRange(node, rightExpr);
         return node;
     }
     BinaryOperationNode.create = create;
 })(BinaryOperationNode || (exports.BinaryOperationNode = BinaryOperationNode = {}));
 var AssignmentExpressionNode;
 (function (AssignmentExpressionNode) {
-    function create(name, walrusToken, rightExpression) {
+    function create(name, walrusToken, rightExpr) {
         const node = {
             start: name.start,
             length: name.length,
             nodeType: 4 /* ParseNodeType.AssignmentExpression */,
             id: _nextNodeId++,
-            name,
-            walrusToken,
-            rightExpression,
-            isParenthesized: false,
+            parent: undefined,
+            a: undefined,
+            d: {
+                name,
+                walrusToken,
+                rightExpr,
+                hasParens: false,
+            },
         };
         name.parent = node;
-        rightExpression.parent = node;
-        extendRange(node, rightExpression);
+        rightExpr.parent = node;
+        extendRange(node, rightExpr);
         return node;
     }
     AssignmentExpressionNode.create = create;
 })(AssignmentExpressionNode || (exports.AssignmentExpressionNode = AssignmentExpressionNode = {}));
 var AssignmentNode;
 (function (AssignmentNode) {
-    function create(leftExpression, rightExpression) {
+    function create(leftExpr, rightExpr) {
         const node = {
-            start: leftExpression.start,
-            length: leftExpression.length,
+            start: leftExpr.start,
+            length: leftExpr.length,
             nodeType: 3 /* ParseNodeType.Assignment */,
             id: _nextNodeId++,
-            leftExpression,
-            rightExpression,
+            parent: undefined,
+            a: undefined,
+            d: {
+                leftExpr,
+                rightExpr,
+            },
         };
-        leftExpression.parent = node;
-        rightExpression.parent = node;
-        extendRange(node, rightExpression);
+        leftExpr.parent = node;
+        rightExpr.parent = node;
+        extendRange(node, rightExpr);
         return node;
     }
     AssignmentNode.create = create;
 })(AssignmentNode || (exports.AssignmentNode = AssignmentNode = {}));
-var TypeParameterCategory;
-(function (TypeParameterCategory) {
-    TypeParameterCategory[TypeParameterCategory["TypeVar"] = 0] = "TypeVar";
-    TypeParameterCategory[TypeParameterCategory["TypeVarTuple"] = 1] = "TypeVarTuple";
-    TypeParameterCategory[TypeParameterCategory["ParamSpec"] = 2] = "ParamSpec";
-})(TypeParameterCategory || (exports.TypeParameterCategory = TypeParameterCategory = {}));
+var TypeParameterKind;
+(function (TypeParameterKind) {
+    TypeParameterKind[TypeParameterKind["TypeVar"] = 0] = "TypeVar";
+    TypeParameterKind[TypeParameterKind["TypeVarTuple"] = 1] = "TypeVarTuple";
+    TypeParameterKind[TypeParameterKind["ParamSpec"] = 2] = "ParamSpec";
+})(TypeParameterKind || (exports.TypeParameterKind = TypeParameterKind = {}));
 var TypeParameterNode;
 (function (TypeParameterNode) {
-    function create(name, typeParamCategory, boundExpression, defaultExpression) {
+    function create(name, typeParamKind, boundExpr, defaultExpr) {
         const node = {
             start: name.start,
             length: name.length,
             nodeType: 75 /* ParseNodeType.TypeParameter */,
             id: _nextNodeId++,
-            name,
-            typeParamCategory,
-            boundExpression,
-            defaultExpression,
+            parent: undefined,
+            a: undefined,
+            d: {
+                name,
+                typeParamKind,
+                boundExpr,
+                defaultExpr,
+            },
         };
         name.parent = node;
-        if (boundExpression) {
-            boundExpression.parent = node;
-            extendRange(node, boundExpression);
+        if (boundExpr) {
+            boundExpr.parent = node;
+            extendRange(node, boundExpr);
         }
-        if (defaultExpression) {
-            defaultExpression.parent = node;
-            extendRange(node, defaultExpression);
+        if (defaultExpr) {
+            defaultExpr.parent = node;
+            extendRange(node, defaultExpr);
         }
         return node;
     }
@@ -632,16 +726,18 @@ var TypeParameterNode;
 })(TypeParameterNode || (exports.TypeParameterNode = TypeParameterNode = {}));
 var TypeParameterListNode;
 (function (TypeParameterListNode) {
-    function create(startToken, endToken, parameters) {
+    function create(startToken, endToken, params) {
         const node = {
             start: startToken.start,
             length: startToken.length,
             nodeType: 76 /* ParseNodeType.TypeParameterList */,
             id: _nextNodeId++,
-            parameters,
+            parent: undefined,
+            a: undefined,
+            d: { params },
         };
         extendRange(node, endToken);
-        parameters.forEach((param) => {
+        params.forEach((param) => {
             extendRange(node, param);
             param.parent = node;
         });
@@ -651,149 +747,179 @@ var TypeParameterListNode;
 })(TypeParameterListNode || (exports.TypeParameterListNode = TypeParameterListNode = {}));
 var TypeAliasNode;
 (function (TypeAliasNode) {
-    function create(typeToken, name, expression, typeParameters) {
+    function create(typeToken, name, expr, typeParams) {
         const node = {
             start: typeToken.start,
             length: typeToken.length,
             nodeType: 77 /* ParseNodeType.TypeAlias */,
             id: _nextNodeId++,
-            name,
-            typeParameters,
-            expression,
+            parent: undefined,
+            a: undefined,
+            d: {
+                name,
+                typeParams,
+                expr,
+            },
         };
         name.parent = node;
-        expression.parent = node;
-        if (typeParameters) {
-            typeParameters.parent = node;
+        expr.parent = node;
+        if (typeParams) {
+            typeParams.parent = node;
         }
-        extendRange(node, expression);
+        extendRange(node, expr);
         return node;
     }
     TypeAliasNode.create = create;
 })(TypeAliasNode || (exports.TypeAliasNode = TypeAliasNode = {}));
 var TypeAnnotationNode;
 (function (TypeAnnotationNode) {
-    function create(valueExpression, typeAnnotation) {
+    function create(valueExpr, annotation) {
         const node = {
-            start: valueExpression.start,
-            length: valueExpression.length,
+            start: valueExpr.start,
+            length: valueExpr.length,
             nodeType: 54 /* ParseNodeType.TypeAnnotation */,
             id: _nextNodeId++,
-            valueExpression,
-            typeAnnotation,
+            parent: undefined,
+            a: undefined,
+            d: {
+                valueExpr,
+                annotation,
+            },
         };
-        valueExpression.parent = node;
-        typeAnnotation.parent = node;
-        extendRange(node, typeAnnotation);
+        valueExpr.parent = node;
+        annotation.parent = node;
+        extendRange(node, annotation);
         return node;
     }
     TypeAnnotationNode.create = create;
 })(TypeAnnotationNode || (exports.TypeAnnotationNode = TypeAnnotationNode = {}));
 var FunctionAnnotationNode;
 (function (FunctionAnnotationNode) {
-    function create(openParenToken, isParamListEllipsis, paramTypeAnnotations, returnTypeAnnotation) {
+    function create(openParenToken, isEllipsis, paramAnnotations, returnAnnotation) {
         const node = {
             start: openParenToken.start,
             length: openParenToken.length,
             nodeType: 62 /* ParseNodeType.FunctionAnnotation */,
             id: _nextNodeId++,
-            isParamListEllipsis,
-            paramTypeAnnotations,
-            returnTypeAnnotation,
+            parent: undefined,
+            a: undefined,
+            d: {
+                isEllipsis,
+                paramAnnotations,
+                returnAnnotation,
+            },
         };
-        paramTypeAnnotations.forEach((p) => {
+        paramAnnotations.forEach((p) => {
             p.parent = node;
         });
-        returnTypeAnnotation.parent = node;
-        extendRange(node, returnTypeAnnotation);
+        returnAnnotation.parent = node;
+        extendRange(node, returnAnnotation);
         return node;
     }
     FunctionAnnotationNode.create = create;
 })(FunctionAnnotationNode || (exports.FunctionAnnotationNode = FunctionAnnotationNode = {}));
 var AugmentedAssignmentNode;
 (function (AugmentedAssignmentNode) {
-    function create(leftExpression, rightExpression, operator, destExpression) {
+    function create(leftExpr, rightExpr, operator, destExpr) {
         const node = {
-            start: leftExpression.start,
-            length: leftExpression.length,
+            start: leftExpr.start,
+            length: leftExpr.length,
             nodeType: 5 /* ParseNodeType.AugmentedAssignment */,
             id: _nextNodeId++,
-            leftExpression,
-            operator,
-            rightExpression,
-            destExpression,
+            parent: undefined,
+            a: undefined,
+            d: {
+                leftExpr,
+                operator,
+                rightExpr,
+                destExpr,
+            },
         };
-        leftExpression.parent = node;
-        rightExpression.parent = node;
-        destExpression.parent = node;
-        extendRange(node, rightExpression);
+        leftExpr.parent = node;
+        rightExpr.parent = node;
+        destExpr.parent = node;
+        extendRange(node, rightExpr);
         return node;
     }
     AugmentedAssignmentNode.create = create;
 })(AugmentedAssignmentNode || (exports.AugmentedAssignmentNode = AugmentedAssignmentNode = {}));
 var AwaitNode;
 (function (AwaitNode) {
-    function create(awaitToken, expression) {
+    function create(awaitToken, expr) {
         const node = {
             start: awaitToken.start,
             length: awaitToken.length,
             nodeType: 6 /* ParseNodeType.Await */,
             id: _nextNodeId++,
-            expression,
+            parent: undefined,
+            a: undefined,
+            d: { expr },
         };
-        expression.parent = node;
-        extendRange(node, expression);
+        expr.parent = node;
+        extendRange(node, expr);
         return node;
     }
     AwaitNode.create = create;
 })(AwaitNode || (exports.AwaitNode = AwaitNode = {}));
 var TernaryNode;
 (function (TernaryNode) {
-    function create(ifExpression, testExpression, elseExpression) {
+    function create(ifExpr, testExpr, elseExpr) {
         const node = {
-            start: ifExpression.start,
-            length: ifExpression.length,
+            start: ifExpr.start,
+            length: ifExpr.length,
             nodeType: 51 /* ParseNodeType.Ternary */,
             id: _nextNodeId++,
-            ifExpression,
-            testExpression,
-            elseExpression,
+            parent: undefined,
+            a: undefined,
+            d: {
+                ifExpr,
+                testExpr,
+                elseExpr,
+            },
         };
-        ifExpression.parent = node;
-        testExpression.parent = node;
-        elseExpression.parent = node;
-        extendRange(node, elseExpression);
+        ifExpr.parent = node;
+        testExpr.parent = node;
+        elseExpr.parent = node;
+        extendRange(node, elseExpr);
         return node;
     }
     TernaryNode.create = create;
 })(TernaryNode || (exports.TernaryNode = TernaryNode = {}));
 var UnpackNode;
 (function (UnpackNode) {
-    function create(starToken, expression) {
+    function create(starToken, expr) {
         const node = {
-            starToken,
             start: starToken.start,
             length: starToken.length,
             nodeType: 56 /* ParseNodeType.Unpack */,
             id: _nextNodeId++,
-            expression,
+            parent: undefined,
+            a: undefined,
+            d: {
+                expr,
+                starToken,
+            },
         };
-        expression.parent = node;
-        extendRange(node, expression);
+        expr.parent = node;
+        extendRange(node, expr);
         return node;
     }
     UnpackNode.create = create;
 })(UnpackNode || (exports.UnpackNode = UnpackNode = {}));
 var TupleNode;
 (function (TupleNode) {
-    function create(range, enclosedInParens) {
+    function create(range, hasParens) {
         const node = {
             start: range.start,
             length: range.length,
             nodeType: 52 /* ParseNodeType.Tuple */,
             id: _nextNodeId++,
-            expressions: [],
-            enclosedInParens,
+            parent: undefined,
+            a: undefined,
+            d: {
+                items: [],
+                hasParens,
+            },
         };
         return node;
     }
@@ -801,24 +927,26 @@ var TupleNode;
 })(TupleNode || (exports.TupleNode = TupleNode = {}));
 var CallNode;
 (function (CallNode) {
-    function create(leftExpression, argList, trailingComma) {
-        var _a;
+    function create(leftExpr, args, trailingComma) {
         const node = {
-            start: leftExpression.start,
-            length: leftExpression.length,
+            start: leftExpr.start,
+            length: leftExpr.length,
             nodeType: 9 /* ParseNodeType.Call */,
             id: _nextNodeId++,
-            leftExpression,
-            arguments: argList,
-            trailingComma,
+            parent: undefined,
+            a: undefined,
+            d: {
+                leftExpr,
+                args,
+                trailingComma,
+            },
         };
-        leftExpression.parent = node;
-        node.maxChildDepth = 1 + ((_a = leftExpression.maxChildDepth) !== null && _a !== void 0 ? _a : 0);
-        if (argList.length > 0) {
-            argList.forEach((arg) => {
+        leftExpr.parent = node;
+        if (args.length > 0) {
+            args.forEach((arg) => {
                 arg.parent = node;
             });
-            extendRange(node, argList[argList.length - 1]);
+            extendRange(node, args[args.length - 1]);
         }
         return node;
     }
@@ -826,40 +954,46 @@ var CallNode;
 })(CallNode || (exports.CallNode = CallNode = {}));
 var ComprehensionNode;
 (function (ComprehensionNode) {
-    function create(expression, isGenerator) {
+    function create(expr, isGenerator) {
         const node = {
-            start: expression.start,
-            length: expression.length,
+            start: expr.start,
+            length: expr.length,
             nodeType: 11 /* ParseNodeType.Comprehension */,
             id: _nextNodeId++,
-            expression,
-            forIfNodes: [],
-            isGenerator,
+            parent: undefined,
+            a: undefined,
+            d: {
+                expr,
+                forIfNodes: [],
+                isGenerator,
+            },
         };
-        expression.parent = node;
+        expr.parent = node;
         return node;
     }
     ComprehensionNode.create = create;
 })(ComprehensionNode || (exports.ComprehensionNode = ComprehensionNode = {}));
 var IndexNode;
 (function (IndexNode) {
-    function create(baseExpression, items, trailingComma, closeBracketToken) {
-        var _a;
+    function create(leftExpr, items, trailingComma, closeBracketToken) {
         const node = {
-            start: baseExpression.start,
-            length: baseExpression.length,
+            start: leftExpr.start,
+            length: leftExpr.length,
             nodeType: 27 /* ParseNodeType.Index */,
             id: _nextNodeId++,
-            baseExpression,
-            items,
-            trailingComma,
+            parent: undefined,
+            a: undefined,
+            d: {
+                leftExpr,
+                items,
+                trailingComma,
+            },
         };
-        baseExpression.parent = node;
+        leftExpr.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;
@@ -872,6 +1006,9 @@ var SliceNode;
             length: range.length,
             nodeType: 46 /* ParseNodeType.Slice */,
             id: _nextNodeId++,
+            parent: undefined,
+            a: undefined,
+            d: {},
         };
         return node;
     }
@@ -879,17 +1016,19 @@ var SliceNode;
 })(SliceNode || (exports.SliceNode = SliceNode = {}));
 var YieldNode;
 (function (YieldNode) {
-    function create(yieldToken, expression) {
+    function create(yieldToken, expr) {
         const node = {
             start: yieldToken.start,
             length: yieldToken.length,
             nodeType: 60 /* ParseNodeType.Yield */,
             id: _nextNodeId++,
-            expression,
+            parent: undefined,
+            a: undefined,
+            d: { expr },
         };
-        if (expression) {
-            expression.parent = node;
-            extendRange(node, expression);
+        if (expr) {
+            expr.parent = node;
+            extendRange(node, expr);
         }
         return node;
     }
@@ -897,53 +1036,61 @@ var YieldNode;
 })(YieldNode || (exports.YieldNode = YieldNode = {}));
 var YieldFromNode;
 (function (YieldFromNode) {
-    function create(yieldToken, expression) {
+    function create(yieldToken, expr) {
         const node = {
             start: yieldToken.start,
             length: yieldToken.length,
             nodeType: 61 /* ParseNodeType.YieldFrom */,
             id: _nextNodeId++,
-            expression,
+            parent: undefined,
+            a: undefined,
+            d: { expr },
         };
-        expression.parent = node;
-        extendRange(node, expression);
+        expr.parent = node;
+        extendRange(node, expr);
         return node;
     }
     YieldFromNode.create = create;
 })(YieldFromNode || (exports.YieldFromNode = YieldFromNode = {}));
 var MemberAccessNode;
 (function (MemberAccessNode) {
-    function create(leftExpression, memberName) {
-        var _a;
+    function create(leftExpr, member) {
         const node = {
-            start: leftExpression.start,
-            length: leftExpression.length,
+            start: leftExpr.start,
+            length: leftExpr.length,
             nodeType: 35 /* ParseNodeType.MemberAccess */,
             id: _nextNodeId++,
-            leftExpression,
-            memberName,
+            parent: undefined,
+            a: undefined,
+            d: {
+                leftExpr: leftExpr,
+                member: member,
+            },
         };
-        leftExpression.parent = node;
-        memberName.parent = node;
-        extendRange(node, memberName);
-        node.maxChildDepth = 1 + ((_a = leftExpression.maxChildDepth) !== null && _a !== void 0 ? _a : 0);
+        leftExpr.parent = node;
+        member.parent = node;
+        extendRange(node, member);
         return node;
     }
     MemberAccessNode.create = create;
 })(MemberAccessNode || (exports.MemberAccessNode = MemberAccessNode = {}));
 var LambdaNode;
 (function (LambdaNode) {
-    function create(lambdaToken, expression) {
+    function create(lambdaToken, expr) {
         const node = {
             start: lambdaToken.start,
             length: lambdaToken.length,
             nodeType: 33 /* ParseNodeType.Lambda */,
             id: _nextNodeId++,
-            parameters: [],
-            expression,
+            parent: undefined,
+            a: undefined,
+            d: {
+                params: [],
+                expr,
+            },
         };
-        expression.parent = node;
-        extendRange(node, expression);
+        expr.parent = node;
+        extendRange(node, expr);
         return node;
     }
     LambdaNode.create = create;
@@ -956,8 +1103,12 @@ var NameNode;
             length: nameToken.length,
             nodeType: 38 /* ParseNodeType.Name */,
             id: _nextNodeId++,
-            token: nameToken,
-            value: nameToken.value,
+            parent: undefined,
+            a: undefined,
+            d: {
+                token: nameToken,
+                value: nameToken.value,
+            },
         };
         return node;
     }
@@ -971,7 +1122,9 @@ var ConstantNode;
             length: token.length,
             nodeType: 14 /* ParseNodeType.Constant */,
             id: _nextNodeId++,
-            constType: token.keywordType,
+            parent: undefined,
+            a: undefined,
+            d: { constType: token.keywordType },
         };
         return node;
     }
@@ -985,6 +1138,9 @@ var EllipsisNode;
             length: range.length,
             nodeType: 21 /* ParseNodeType.Ellipsis */,
             id: _nextNodeId++,
+            parent: undefined,
+            a: undefined,
+            d: {},
         };
         return node;
     }
@@ -998,9 +1154,13 @@ var NumberNode;
             length: token.length,
             nodeType: 40 /* ParseNodeType.Number */,
             id: _nextNodeId++,
-            value: token.value,
-            isInteger: token.isInteger,
-            isImaginary: token.isImaginary,
+            parent: undefined,
+            a: undefined,
+            d: {
+                value: token.value,
+                isInteger: token.isInteger,
+                isImaginary: token.isImaginary,
+            },
         };
         return node;
     }
@@ -1008,14 +1168,18 @@ var NumberNode;
 })(NumberNode || (exports.NumberNode = NumberNode = {}));
 var StringNode;
 (function (StringNode) {
-    function create(token, unescapedValue) {
+    function create(token, value) {
         const node = {
             start: token.start,
             length: token.length,
             nodeType: 49 /* ParseNodeType.String */,
             id: _nextNodeId++,
-            token,
-            value: unescapedValue,
+            parent: undefined,
+            a: undefined,
+            d: {
+                token,
+                value,
+            },
         };
         return node;
     }
@@ -1023,24 +1187,28 @@ var StringNode;
 })(StringNode || (exports.StringNode = StringNode = {}));
 var FormatStringNode;
 (function (FormatStringNode) {
-    function create(startToken, endToken, middleTokens, fieldExpressions, formatExpressions) {
+    function create(startToken, endToken, middleTokens, fieldExprs, formatExprs) {
         const node = {
             start: startToken.start,
             length: startToken.length,
             nodeType: 30 /* ParseNodeType.FormatString */,
             id: _nextNodeId++,
-            token: startToken,
-            middleTokens,
-            fieldExpressions,
-            formatExpressions,
-            value: '',
+            parent: undefined,
+            a: undefined,
+            d: {
+                token: startToken,
+                middleTokens,
+                fieldExprs,
+                formatExprs,
+                value: '',
+            },
         };
-        fieldExpressions.forEach((expr) => {
+        fieldExprs.forEach((expr) => {
             expr.parent = node;
             extendRange(node, expr);
         });
-        if (formatExpressions) {
-            formatExpressions.forEach((expr) => {
+        if (formatExprs) {
+            formatExprs.forEach((expr) => {
                 expr.parent = node;
                 extendRange(node, expr);
             });
@@ -1060,7 +1228,13 @@ var StringListNode;
             length: strings[0].length,
             nodeType: 48 /* ParseNodeType.StringList */,
             id: _nextNodeId++,
-            strings,
+            parent: undefined,
+            a: undefined,
+            d: {
+                strings,
+                annotation: undefined,
+                hasParens: false,
+            },
         };
         if (strings.length > 0) {
             strings.forEach((str) => {
@@ -1080,7 +1254,12 @@ var DictionaryNode;
             length: range.length,
             nodeType: 18 /* ParseNodeType.Dictionary */,
             id: _nextNodeId++,
-            entries: [],
+            parent: undefined,
+            a: undefined,
+            d: {
+                items: [],
+                trailingCommaToken: undefined,
+            },
         };
         return node;
     }
@@ -1088,33 +1267,39 @@ var DictionaryNode;
 })(DictionaryNode || (exports.DictionaryNode = DictionaryNode = {}));
 var DictionaryKeyEntryNode;
 (function (DictionaryKeyEntryNode) {
-    function create(keyExpression, valueExpression) {
+    function create(keyExpr, valueExpr) {
         const node = {
-            start: keyExpression.start,
-            length: keyExpression.length,
+            start: keyExpr.start,
+            length: keyExpr.length,
             nodeType: 20 /* ParseNodeType.DictionaryKeyEntry */,
             id: _nextNodeId++,
-            keyExpression,
-            valueExpression,
+            parent: undefined,
+            a: undefined,
+            d: {
+                keyExpr,
+                valueExpr,
+            },
         };
-        keyExpression.parent = node;
-        valueExpression.parent = node;
-        extendRange(node, valueExpression);
+        keyExpr.parent = node;
+        valueExpr.parent = node;
+        extendRange(node, valueExpr);
         return node;
     }
     DictionaryKeyEntryNode.create = create;
 })(DictionaryKeyEntryNode || (exports.DictionaryKeyEntryNode = DictionaryKeyEntryNode = {}));
 var DictionaryExpandEntryNode;
 (function (DictionaryExpandEntryNode) {
-    function create(expandExpression) {
+    function create(expr) {
         const node = {
-            start: expandExpression.start,
-            length: expandExpression.length,
+            start: expr.start,
+            length: expr.length,
             nodeType: 19 /* ParseNodeType.DictionaryExpandEntry */,
             id: _nextNodeId++,
-            expandExpression,
+            parent: undefined,
+            a: undefined,
+            d: { expr },
         };
-        expandExpression.parent = node;
+        expr.parent = node;
         return node;
     }
     DictionaryExpandEntryNode.create = create;
@@ -1127,7 +1312,9 @@ var SetNode;
             length: range.length,
             nodeType: 45 /* ParseNodeType.Set */,
             id: _nextNodeId++,
-            entries: [],
+            parent: undefined,
+            a: undefined,
+            d: { items: [] },
         };
         return node;
     }
@@ -1141,7 +1328,9 @@ var ListNode;
             length: range.length,
             nodeType: 34 /* ParseNodeType.List */,
             id: _nextNodeId++,
-            entries: [],
+            parent: undefined,
+            a: undefined,
+            d: { items: [] },
         };
         return node;
     }
@@ -1155,17 +1344,22 @@ var ArgumentCategory;
 })(ArgumentCategory || (exports.ArgumentCategory = ArgumentCategory = {}));
 var ArgumentNode;
 (function (ArgumentNode) {
-    function create(startToken, valueExpression, argCategory) {
+    function create(startToken, valueExpr, argCategory) {
         const node = {
-            start: startToken ? startToken.start : valueExpression.start,
-            length: startToken ? startToken.length : valueExpression.length,
+            start: startToken ? startToken.start : valueExpr.start,
+            length: startToken ? startToken.length : valueExpr.length,
             nodeType: 1 /* ParseNodeType.Argument */,
             id: _nextNodeId++,
-            valueExpression,
-            argumentCategory: argCategory,
+            parent: undefined,
+            a: undefined,
+            d: {
+                argCategory,
+                name: undefined,
+                valueExpr,
+            },
         };
-        valueExpression.parent = node;
-        extendRange(node, valueExpression);
+        valueExpr.parent = node;
+        extendRange(node, valueExpr);
         return node;
     }
     ArgumentNode.create = create;
@@ -1178,7 +1372,9 @@ var DelNode;
             length: delToken.length,
             nodeType: 17 /* ParseNodeType.Del */,
             id: _nextNodeId++,
-            expressions: [],
+            parent: undefined,
+            a: undefined,
+            d: { targets: [] },
         };
         return node;
     }
@@ -1192,6 +1388,9 @@ var PassNode;
             length: passToken.length,
             nodeType: 42 /* ParseNodeType.Pass */,
             id: _nextNodeId++,
+            parent: undefined,
+            a: undefined,
+            d: {},
         };
         return node;
     }
@@ -1199,13 +1398,15 @@ var PassNode;
 })(PassNode || (exports.PassNode = PassNode = {}));
 var ImportNode;
 (function (ImportNode) {
-    function create(passToken) {
+    function create(importToken) {
         const node = {
-            start: passToken.start,
-            length: passToken.length,
+            start: importToken.start,
+            length: importToken.length,
             nodeType: 23 /* ParseNodeType.Import */,
             id: _nextNodeId++,
-            list: [],
+            parent: undefined,
+            a: undefined,
+            d: { list: [] },
         };
         return node;
     }
@@ -1219,8 +1420,12 @@ var ModuleNameNode;
             length: range.length,
             nodeType: 37 /* ParseNodeType.ModuleName */,
             id: _nextNodeId++,
-            leadingDots: 0,
-            nameParts: [],
+            parent: undefined,
+            a: undefined,
+            d: {
+                leadingDots: 0,
+                nameParts: [],
+            },
         };
         return node;
     }
@@ -1234,7 +1439,9 @@ var ImportAsNode;
             length: module.length,
             nodeType: 24 /* ParseNodeType.ImportAs */,
             id: _nextNodeId++,
-            module,
+            parent: undefined,
+            a: undefined,
+            d: { module: module },
         };
         module.parent = node;
         return node;
@@ -1249,10 +1456,14 @@ var ImportFromNode;
             length: fromToken.length,
             nodeType: 25 /* ParseNodeType.ImportFrom */,
             id: _nextNodeId++,
-            module,
-            imports: [],
-            isWildcardImport: false,
-            usesParens: false,
+            parent: undefined,
+            a: undefined,
+            d: {
+                module,
+                imports: [],
+                isWildcardImport: false,
+                usesParens: false,
+            },
         };
         module.parent = node;
         extendRange(node, module);
@@ -1268,7 +1479,9 @@ var ImportFromAsNode;
             length: name.length,
             nodeType: 26 /* ParseNodeType.ImportFromAs */,
             id: _nextNodeId++,
-            name,
+            parent: undefined,
+            a: undefined,
+            d: { name: name },
         };
         name.parent = node;
         return node;
@@ -1283,7 +1496,9 @@ var GlobalNode;
             length: range.length,
             nodeType: 32 /* ParseNodeType.Global */,
             id: _nextNodeId++,
-            nameList: [],
+            parent: undefined,
+            a: undefined,
+            d: { targets: [] },
         };
         return node;
     }
@@ -1297,7 +1512,9 @@ var NonlocalNode;
             length: range.length,
             nodeType: 39 /* ParseNodeType.Nonlocal */,
             id: _nextNodeId++,
-            nameList: [],
+            parent: undefined,
+            a: undefined,
+            d: { targets: [] },
         };
         return node;
     }
@@ -1305,16 +1522,18 @@ var NonlocalNode;
 })(NonlocalNode || (exports.NonlocalNode = NonlocalNode = {}));
 var AssertNode;
 (function (AssertNode) {
-    function create(assertToken, testExpression) {
+    function create(assertToken, testExpr) {
         const node = {
             start: assertToken.start,
             length: assertToken.length,
             nodeType: 2 /* ParseNodeType.Assert */,
             id: _nextNodeId++,
-            testExpression,
+            parent: undefined,
+            a: undefined,
+            d: { testExpr },
         };
-        testExpression.parent = node;
-        extendRange(node, testExpression);
+        testExpr.parent = node;
+        extendRange(node, testExpr);
         return node;
     }
     AssertNode.create = create;
@@ -1327,6 +1546,9 @@ var BreakNode;
             length: range.length,
             nodeType: 8 /* ParseNodeType.Break */,
             id: _nextNodeId++,
+            parent: undefined,
+            a: undefined,
+            d: {},
         };
         return node;
     }
@@ -1340,6 +1562,9 @@ var ContinueNode;
             length: range.length,
             nodeType: 15 /* ParseNodeType.Continue */,
             id: _nextNodeId++,
+            parent: undefined,
+            a: undefined,
+            d: {},
         };
         return node;
     }
@@ -1353,6 +1578,9 @@ var ReturnNode;
             length: range.length,
             nodeType: 44 /* ParseNodeType.Return */,
             id: _nextNodeId++,
+            parent: undefined,
+            a: undefined,
+            d: {},
         };
         return node;
     }
@@ -1366,6 +1594,9 @@ var RaiseNode;
             length: range.length,
             nodeType: 43 /* ParseNodeType.Raise */,
             id: _nextNodeId++,
+            parent: undefined,
+            a: undefined,
+            d: {},
         };
         return node;
     }
@@ -1373,39 +1604,47 @@ var RaiseNode;
 })(RaiseNode || (exports.RaiseNode = RaiseNode = {}));
 var MatchNode;
 (function (MatchNode) {
-    function create(matchToken, subjectExpression) {
+    function create(matchToken, expr) {
         const node = {
             start: matchToken.start,
             length: matchToken.length,
             nodeType: 63 /* ParseNodeType.Match */,
             id: _nextNodeId++,
-            subjectExpression,
-            cases: [],
+            parent: undefined,
+            a: undefined,
+            d: {
+                expr,
+                cases: [],
+            },
         };
-        subjectExpression.parent = node;
-        extendRange(node, subjectExpression);
+        expr.parent = node;
+        extendRange(node, expr);
         return node;
     }
     MatchNode.create = create;
 })(MatchNode || (exports.MatchNode = MatchNode = {}));
 var CaseNode;
 (function (CaseNode) {
-    function create(caseToken, pattern, isIrrefutable, guardExpression, suite) {
+    function create(caseToken, pattern, isIrrefutable, guardExpr, suite) {
         const node = {
             start: caseToken.start,
             length: caseToken.length,
             nodeType: 64 /* ParseNodeType.Case */,
             id: _nextNodeId++,
-            pattern,
-            isIrrefutable,
-            guardExpression,
-            suite,
+            parent: undefined,
+            a: undefined,
+            d: {
+                pattern,
+                isIrrefutable,
+                guardExpr,
+                suite,
+            },
         };
         extendRange(node, suite);
         pattern.parent = node;
         suite.parent = node;
-        if (guardExpression) {
-            guardExpression.parent = node;
+        if (guardExpr) {
+            guardExpr.parent = node;
         }
         return node;
     }
@@ -1414,16 +1653,20 @@ var CaseNode;
 var PatternSequenceNode;
 (function (PatternSequenceNode) {
     function create(firstToken, entries) {
-        const starEntryIndex = entries.findIndex((entry) => entry.orPatterns.length === 1 &&
-            entry.orPatterns[0].nodeType === 69 /* ParseNodeType.PatternCapture */ &&
-            entry.orPatterns[0].isStar);
+        const starEntryIndex = entries.findIndex((entry) => entry.d.orPatterns.length === 1 &&
+            entry.d.orPatterns[0].nodeType === 69 /* ParseNodeType.PatternCapture */ &&
+            entry.d.orPatterns[0].d.isStar);
         const node = {
             start: firstToken.start,
             length: firstToken.length,
             nodeType: 65 /* ParseNodeType.PatternSequence */,
             id: _nextNodeId++,
-            entries,
-            starEntryIndex: starEntryIndex >= 0 ? starEntryIndex : undefined,
+            parent: undefined,
+            a: undefined,
+            d: {
+                entries,
+                starEntryIndex: starEntryIndex >= 0 ? starEntryIndex : undefined,
+            },
         };
         if (entries.length > 0) {
             extendRange(node, entries[entries.length - 1]);
@@ -1443,8 +1686,12 @@ var PatternAsNode;
             length: orPatterns[0].length,
             nodeType: 66 /* ParseNodeType.PatternAs */,
             id: _nextNodeId++,
-            orPatterns,
-            target,
+            parent: undefined,
+            a: undefined,
+            d: {
+                orPatterns,
+                target,
+            },
         };
         if (orPatterns.length > 1) {
             extendRange(node, orPatterns[orPatterns.length - 1]);
@@ -1462,15 +1709,17 @@ var PatternAsNode;
 })(PatternAsNode || (exports.PatternAsNode = PatternAsNode = {}));
 var PatternLiteralNode;
 (function (PatternLiteralNode) {
-    function create(expression) {
+    function create(expr) {
         const node = {
-            start: expression.start,
-            length: expression.length,
+            start: expr.start,
+            length: expr.length,
             nodeType: 67 /* ParseNodeType.PatternLiteral */,
             id: _nextNodeId++,
-            expression,
+            parent: undefined,
+            a: undefined,
+            d: { expr },
         };
-        expression.parent = node;
+        expr.parent = node;
         return node;
     }
     PatternLiteralNode.create = create;
@@ -1483,8 +1732,12 @@ var PatternClassNode;
             length: className.length,
             nodeType: 68 /* ParseNodeType.PatternClass */,
             id: _nextNodeId++,
-            className,
-            arguments: args,
+            parent: undefined,
+            a: undefined,
+            d: {
+                className,
+                args,
+            },
         };
         className.parent = node;
         args.forEach((arg) => {
@@ -1505,8 +1758,12 @@ var PatternClassArgumentNode;
             length: pattern.length,
             nodeType: 74 /* ParseNodeType.PatternClassArgument */,
             id: _nextNodeId++,
-            pattern,
-            name,
+            parent: undefined,
+            a: undefined,
+            d: {
+                pattern,
+                name,
+            },
         };
         pattern.parent = node;
         if (name) {
@@ -1525,9 +1782,13 @@ var PatternCaptureNode;
             length: target.length,
             nodeType: 69 /* ParseNodeType.PatternCapture */,
             id: _nextNodeId++,
-            target,
-            isStar: starToken !== undefined,
-            isWildcard: target.value === '_',
+            parent: undefined,
+            a: undefined,
+            d: {
+                target,
+                isStar: starToken !== undefined,
+                isWildcard: target.d.value === '_',
+            },
         };
         target.parent = node;
         if (starToken) {
@@ -1545,7 +1806,9 @@ var PatternMappingNode;
             length: startToken.length,
             nodeType: 70 /* ParseNodeType.PatternMapping */,
             id: _nextNodeId++,
-            entries,
+            parent: undefined,
+            a: undefined,
+            d: { entries },
         };
         if (entries.length > 0) {
             extendRange(node, entries[entries.length - 1]);
@@ -1565,8 +1828,12 @@ var PatternMappingKeyEntryNode;
             length: keyPattern.length,
             nodeType: 71 /* ParseNodeType.PatternMappingKeyEntry */,
             id: _nextNodeId++,
-            keyPattern,
-            valuePattern,
+            parent: undefined,
+            a: undefined,
+            d: {
+                keyPattern,
+                valuePattern,
+            },
         };
         keyPattern.parent = node;
         valuePattern.parent = node;
@@ -1583,7 +1850,9 @@ var PatternMappingExpandEntryNode;
             length: starStarToken.length,
             nodeType: 72 /* ParseNodeType.PatternMappingExpandEntry */,
             id: _nextNodeId++,
-            target,
+            parent: undefined,
+            a: undefined,
+            d: { target },
         };
         target.parent = node;
         extendRange(node, target);
@@ -1593,15 +1862,17 @@ var PatternMappingExpandEntryNode;
 })(PatternMappingExpandEntryNode || (exports.PatternMappingExpandEntryNode = PatternMappingExpandEntryNode = {}));
 var PatternValueNode;
 (function (PatternValueNode) {
-    function create(expression) {
+    function create(expr) {
         const node = {
-            start: expression.start,
-            length: expression.length,
+            start: expr.start,
+            length: expr.length,
             nodeType: 73 /* ParseNodeType.PatternValue */,
             id: _nextNodeId++,
-            expression,
+            parent: undefined,
+            a: undefined,
+            d: { expr },
         };
-        expression.parent = node;
+        expr.parent = node;
         return node;
     }
     PatternValueNode.create = create;