@zzzen/pyright-internal 1.2.0-dev.20260816 → 1.2.0-dev.20260823

package/dist/parser/parseNodes.js

@@ -11,10 +11,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 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.ComprehensionNode = exports.CallNode = exports.TupleNode = exports.UnpackNode = exports.TernaryNode = exports.AwaitNode = exports.AugmentedAssignmentNode = exports.FunctionAnnotationNode = exports.TypeAnnotationNode = exports.TypeAliasNode = exports.TypeParameterListNode = exports.TypeParameterNode = exports.TypeParamKind = exports.AssignmentNode = exports.AssignmentExpressionNode = exports.BinaryOperationNode = exports.UnaryOperationNode = exports.ErrorNode = exports.StatementListNode = exports.DecoratorNode = exports.WithItemNode = exports.WithNode = exports.ClassNode = exports.ParameterNode = exports.ParamCategory = exports.FunctionNode = exports.ExceptNode = exports.TryNode = exports.ComprehensionIfNode = exports.ComprehensionForNode = exports.ForNode = exports.WhileNode = exports.IfNode = exports.SuiteNode = exports.ModuleNode = 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.ArgCategory = exports.ListNode = exports.SetNode = exports.DictionaryExpandEntryNode = exports.DictionaryKeyEntryNode = exports.DictionaryNode = void 0;
+exports.setParserStringAnnotationInfo = setParserStringAnnotationInfo;
+exports.getParseTreeRoot = getParseTreeRoot;
+exports.getParserStringAnnotation = getParserStringAnnotation;
+exports.getParserStringAnnotationInfo = getParserStringAnnotationInfo;
 exports.getNextNodeId = getNextNodeId;
 exports.extendRange = extendRange;
 exports.isExpressionNode = isExpressionNode;
 const textRange_1 = require("../common/textRange");
+const stringAnnotationInfo_1 = require("./stringAnnotationInfo");
 var ParseNodeType;
 (function (ParseNodeType) {
     ParseNodeType[ParseNodeType["Error"] = 0] = "Error";
@@ -115,6 +120,22 @@ var ErrorExpressionCategory;
     ErrorExpressionCategory[ErrorExpressionCategory["MissingKeywordArgValue"] = 14] = "MissingKeywordArgValue";
     ErrorExpressionCategory[ErrorExpressionCategory["MaxDepthExceeded"] = 15] = "MaxDepthExceeded";
 })(ErrorExpressionCategory || (exports.ErrorExpressionCategory = ErrorExpressionCategory = {}));
+function setParserStringAnnotationInfo(key, stringAnnotations) {
+    key.stringAnnotations = stringAnnotations;
+}
+function getParseTreeRoot(node) {
+    // The owner key is the module node itself for file parses (so its nodeType is
+    // Module), or a plain standalone key object for detached expression parses
+    // (nodeType is undefined). Only the former has a real parse-tree root.
+    const key = node.a;
+    return key.nodeType === 36 /* ParseNodeType.Module */ ? key : undefined;
+}
+function getParserStringAnnotation(node) {
+    return node.a.stringAnnotations?.get(node);
+}
+function getParserStringAnnotationInfo(node) {
+    return node.a.stringAnnotations ?? stringAnnotationInfo_1.emptyStringAnnotationInfo;
+}
 let _nextNodeId = 1;
 function getNextNodeId() {
     return _nextNodeId++;
@@ -137,20 +158,23 @@ var ModuleNode;
             a: undefined,
             d: { statements: [] },
         };
+        // The module node is its own owner key; every structural node in a file
+        // parse shares this reference via its `a` field.
+        node.a = node;
         return node;
     }
     ModuleNode.create = create;
 })(ModuleNode || (exports.ModuleNode = ModuleNode = {}));
 var SuiteNode;
 (function (SuiteNode) {
-    function create(range) {
+    function create(key, range) {
         const node = {
             start: range.start,
             length: range.length,
             nodeType: 50 /* ParseNodeType.Suite */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 statements: [],
                 typeComment: undefined,
@@ -162,14 +186,14 @@ var SuiteNode;
 })(SuiteNode || (exports.SuiteNode = SuiteNode = {}));
 var IfNode;
 (function (IfNode) {
-    function create(ifOrElifToken, testExpr, ifSuite, elseSuite) {
+    function create(key, ifOrElifToken, testExpr, ifSuite, elseSuite) {
         const node = {
             start: ifOrElifToken.start,
             length: ifOrElifToken.length,
             nodeType: 22 /* ParseNodeType.If */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 firstToken: ifOrElifToken,
                 testExpr,
@@ -191,14 +215,14 @@ var IfNode;
 })(IfNode || (exports.IfNode = IfNode = {}));
 var WhileNode;
 (function (WhileNode) {
-    function create(whileToken, testExpr, whileSuite) {
+    function create(key, whileToken, testExpr, whileSuite) {
         const node = {
             start: whileToken.start,
             length: whileToken.length,
             nodeType: 57 /* ParseNodeType.While */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 firstToken: whileToken,
                 testExpr,
@@ -214,14 +238,14 @@ var WhileNode;
 })(WhileNode || (exports.WhileNode = WhileNode = {}));
 var ForNode;
 (function (ForNode) {
-    function create(forToken, targetExpr, iterableExpr, forSuite) {
+    function create(key, forToken, targetExpr, iterableExpr, forSuite) {
         const node = {
             start: forToken.start,
             length: forToken.length,
             nodeType: 29 /* ParseNodeType.For */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 firstToken: forToken,
                 targetExpr,
@@ -239,14 +263,14 @@ var ForNode;
 })(ForNode || (exports.ForNode = ForNode = {}));
 var ComprehensionForNode;
 (function (ComprehensionForNode) {
-    function create(startToken, targetExpr, iterableExpr) {
+    function create(key, startToken, targetExpr, iterableExpr) {
         const node = {
             start: startToken.start,
             length: startToken.length,
             nodeType: 12 /* ParseNodeType.ComprehensionFor */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 targetExpr,
                 iterableExpr,
@@ -262,14 +286,14 @@ var ComprehensionForNode;
 })(ComprehensionForNode || (exports.ComprehensionForNode = ComprehensionForNode = {}));
 var ComprehensionIfNode;
 (function (ComprehensionIfNode) {
-    function create(ifToken, testExpr) {
+    function create(key, ifToken, testExpr) {
         const node = {
             start: ifToken.start,
             length: ifToken.length,
             nodeType: 13 /* ParseNodeType.ComprehensionIf */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: { testExpr },
         };
         testExpr.parent = node;
@@ -280,14 +304,14 @@ var ComprehensionIfNode;
 })(ComprehensionIfNode || (exports.ComprehensionIfNode = ComprehensionIfNode = {}));
 var TryNode;
 (function (TryNode) {
-    function create(tryToken, trySuite) {
+    function create(key, tryToken, trySuite) {
         const node = {
             start: tryToken.start,
             length: tryToken.length,
             nodeType: 53 /* ParseNodeType.Try */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 firstToken: tryToken,
                 trySuite: trySuite,
@@ -302,14 +326,14 @@ var TryNode;
 })(TryNode || (exports.TryNode = TryNode = {}));
 var ExceptNode;
 (function (ExceptNode) {
-    function create(exceptToken, exceptSuite, isExceptGroup) {
+    function create(key, exceptToken, exceptSuite, isExceptGroup) {
         const node = {
             start: exceptToken.start,
             length: exceptToken.length,
             nodeType: 28 /* ParseNodeType.Except */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 exceptSuite: exceptSuite,
                 isExceptGroup: isExceptGroup,
@@ -324,14 +348,14 @@ var ExceptNode;
 })(ExceptNode || (exports.ExceptNode = ExceptNode = {}));
 var FunctionNode;
 (function (FunctionNode) {
-    function create(defToken, name, suite, typeParams) {
+    function create(key, defToken, name, suite, typeParams) {
         const node = {
             start: defToken.start,
             length: defToken.length,
             nodeType: 31 /* ParseNodeType.Function */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 firstToken: defToken,
                 decorators: [],
@@ -362,14 +386,14 @@ var ParamCategory;
 })(ParamCategory || (exports.ParamCategory = ParamCategory = {}));
 var ParameterNode;
 (function (ParameterNode) {
-    function create(startToken, paramCategory) {
+    function create(key, startToken, paramCategory) {
         const node = {
             start: startToken.start,
             length: startToken.length,
             nodeType: 41 /* ParseNodeType.Parameter */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 category: paramCategory,
                 name: undefined,
@@ -384,14 +408,14 @@ var ParameterNode;
 })(ParameterNode || (exports.ParameterNode = ParameterNode = {}));
 var ClassNode;
 (function (ClassNode) {
-    function create(classToken, name, suite, typeParams) {
+    function create(key, classToken, name, suite, typeParams) {
         const node = {
             start: classToken.start,
             length: classToken.length,
             nodeType: 10 /* ParseNodeType.Class */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 firstToken: classToken,
                 decorators: [],
@@ -413,14 +437,14 @@ var ClassNode;
     // This variant is used to create a dummy class
     // when the parser encounters decorators with no
     // function or class declaration.
-    function createDummyForDecorators(decorators) {
+    function createDummyForDecorators(key, decorators) {
         const node = {
             start: decorators[0].start,
             length: 0,
             nodeType: 10 /* ParseNodeType.Class */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 firstToken: {
                     type: 8 /* TokenType.Keyword */,
@@ -435,7 +459,7 @@ var ClassNode;
                     nodeType: 38 /* ParseNodeType.Name */,
                     id: 0,
                     parent: undefined,
-                    a: undefined,
+                    a: key,
                     d: {
                         token: {
                             type: 7 /* TokenType.Identifier */,
@@ -455,7 +479,7 @@ var ClassNode;
                     nodeType: 50 /* ParseNodeType.Suite */,
                     id: 0,
                     parent: undefined,
-                    a: undefined,
+                    a: key,
                     d: { statements: [], typeComment: undefined },
                 },
             },
@@ -472,14 +496,14 @@ var ClassNode;
 })(ClassNode || (exports.ClassNode = ClassNode = {}));
 var WithNode;
 (function (WithNode) {
-    function create(withToken, suite) {
+    function create(key, withToken, suite) {
         const node = {
             start: withToken.start,
             length: withToken.length,
             nodeType: 58 /* ParseNodeType.With */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 firstToken: withToken,
                 withItems: [],
@@ -494,14 +518,14 @@ var WithNode;
 })(WithNode || (exports.WithNode = WithNode = {}));
 var WithItemNode;
 (function (WithItemNode) {
-    function create(expr) {
+    function create(key, expr) {
         const node = {
             start: expr.start,
             length: expr.length,
             nodeType: 59 /* ParseNodeType.WithItem */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: { expr },
         };
         expr.parent = node;
@@ -511,14 +535,14 @@ var WithItemNode;
 })(WithItemNode || (exports.WithItemNode = WithItemNode = {}));
 var DecoratorNode;
 (function (DecoratorNode) {
-    function create(atToken, expr) {
+    function create(key, atToken, expr) {
         const node = {
             start: atToken.start,
             length: atToken.length,
             nodeType: 16 /* ParseNodeType.Decorator */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: { expr },
         };
         expr.parent = node;
@@ -529,14 +553,14 @@ var DecoratorNode;
 })(DecoratorNode || (exports.DecoratorNode = DecoratorNode = {}));
 var StatementListNode;
 (function (StatementListNode) {
-    function create(atToken) {
+    function create(key, atToken) {
         const node = {
             start: atToken.start,
             length: atToken.length,
             nodeType: 47 /* ParseNodeType.StatementList */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: { firstToken: atToken, statements: [] },
         };
         return node;
@@ -579,14 +603,14 @@ function isExpressionNode(node) {
 }
 var ErrorNode;
 (function (ErrorNode) {
-    function create(initialRange, category, child, decorators) {
+    function create(key, initialRange, category, child, decorators) {
         const node = {
             start: initialRange.start,
             length: initialRange.length,
             nodeType: 0 /* ParseNodeType.Error */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 category,
                 child,
@@ -611,14 +635,14 @@ var ErrorNode;
 })(ErrorNode || (exports.ErrorNode = ErrorNode = {}));
 var UnaryOperationNode;
 (function (UnaryOperationNode) {
-    function create(operatorToken, expr, operator) {
+    function create(key, operatorToken, expr, operator) {
         const node = {
             start: operatorToken.start,
             length: operatorToken.length,
             nodeType: 55 /* ParseNodeType.UnaryOperation */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 operator,
                 operatorToken,
@@ -634,14 +658,14 @@ var UnaryOperationNode;
 })(UnaryOperationNode || (exports.UnaryOperationNode = UnaryOperationNode = {}));
 var BinaryOperationNode;
 (function (BinaryOperationNode) {
-    function create(leftExpr, rightExpr, operatorToken, operator) {
+    function create(key, leftExpr, rightExpr, operatorToken, operator) {
         const node = {
             start: leftExpr.start,
             length: leftExpr.length,
             nodeType: 7 /* ParseNodeType.BinaryOperation */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 leftExpr,
                 operatorToken,
@@ -659,14 +683,14 @@ var BinaryOperationNode;
 })(BinaryOperationNode || (exports.BinaryOperationNode = BinaryOperationNode = {}));
 var AssignmentExpressionNode;
 (function (AssignmentExpressionNode) {
-    function create(name, walrusToken, rightExpr) {
+    function create(key, name, walrusToken, rightExpr) {
         const node = {
             start: name.start,
             length: name.length,
             nodeType: 4 /* ParseNodeType.AssignmentExpression */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 name,
                 walrusToken,
@@ -683,14 +707,14 @@ var AssignmentExpressionNode;
 })(AssignmentExpressionNode || (exports.AssignmentExpressionNode = AssignmentExpressionNode = {}));
 var AssignmentNode;
 (function (AssignmentNode) {
-    function create(leftExpr, rightExpr) {
+    function create(key, leftExpr, rightExpr) {
         const node = {
             start: leftExpr.start,
             length: leftExpr.length,
             nodeType: 3 /* ParseNodeType.Assignment */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 leftExpr,
                 rightExpr,
@@ -711,14 +735,14 @@ var TypeParamKind;
 })(TypeParamKind || (exports.TypeParamKind = TypeParamKind = {}));
 var TypeParameterNode;
 (function (TypeParameterNode) {
-    function create(name, typeParamKind, boundExpr, defaultExpr) {
+    function create(key, name, typeParamKind, boundExpr, defaultExpr) {
         const node = {
             start: name.start,
             length: name.length,
             nodeType: 75 /* ParseNodeType.TypeParameter */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 name,
                 typeParamKind,
@@ -741,14 +765,14 @@ var TypeParameterNode;
 })(TypeParameterNode || (exports.TypeParameterNode = TypeParameterNode = {}));
 var TypeParameterListNode;
 (function (TypeParameterListNode) {
-    function create(startToken, endToken, params) {
+    function create(key, startToken, endToken, params) {
         const node = {
             start: startToken.start,
             length: startToken.length,
             nodeType: 76 /* ParseNodeType.TypeParameterList */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: { params },
         };
         extendRange(node, endToken);
@@ -762,14 +786,14 @@ var TypeParameterListNode;
 })(TypeParameterListNode || (exports.TypeParameterListNode = TypeParameterListNode = {}));
 var TypeAliasNode;
 (function (TypeAliasNode) {
-    function create(typeToken, name, expr, typeParams) {
+    function create(key, typeToken, name, expr, typeParams) {
         const node = {
             start: typeToken.start,
             length: typeToken.length,
             nodeType: 77 /* ParseNodeType.TypeAlias */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 firstToken: typeToken,
                 name,
@@ -789,14 +813,14 @@ var TypeAliasNode;
 })(TypeAliasNode || (exports.TypeAliasNode = TypeAliasNode = {}));
 var TypeAnnotationNode;
 (function (TypeAnnotationNode) {
-    function create(valueExpr, annotation) {
+    function create(key, valueExpr, annotation) {
         const node = {
             start: valueExpr.start,
             length: valueExpr.length,
             nodeType: 54 /* ParseNodeType.TypeAnnotation */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 valueExpr,
                 annotation,
@@ -811,14 +835,14 @@ var TypeAnnotationNode;
 })(TypeAnnotationNode || (exports.TypeAnnotationNode = TypeAnnotationNode = {}));
 var FunctionAnnotationNode;
 (function (FunctionAnnotationNode) {
-    function create(openParenToken, isEllipsis, paramAnnotations, returnAnnotation) {
+    function create(key, openParenToken, isEllipsis, paramAnnotations, returnAnnotation) {
         const node = {
             start: openParenToken.start,
             length: openParenToken.length,
             nodeType: 62 /* ParseNodeType.FunctionAnnotation */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 isEllipsis,
                 paramAnnotations,
@@ -836,14 +860,14 @@ var FunctionAnnotationNode;
 })(FunctionAnnotationNode || (exports.FunctionAnnotationNode = FunctionAnnotationNode = {}));
 var AugmentedAssignmentNode;
 (function (AugmentedAssignmentNode) {
-    function create(leftExpr, rightExpr, operator, destExpr) {
+    function create(key, leftExpr, rightExpr, operator, destExpr) {
         const node = {
             start: leftExpr.start,
             length: leftExpr.length,
             nodeType: 5 /* ParseNodeType.AugmentedAssignment */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 leftExpr,
                 operator,
@@ -861,14 +885,14 @@ var AugmentedAssignmentNode;
 })(AugmentedAssignmentNode || (exports.AugmentedAssignmentNode = AugmentedAssignmentNode = {}));
 var AwaitNode;
 (function (AwaitNode) {
-    function create(awaitToken, expr) {
+    function create(key, awaitToken, expr) {
         const node = {
             start: awaitToken.start,
             length: awaitToken.length,
             nodeType: 6 /* ParseNodeType.Await */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: { expr, awaitToken, hasParens: false },
         };
         expr.parent = node;
@@ -879,14 +903,14 @@ var AwaitNode;
 })(AwaitNode || (exports.AwaitNode = AwaitNode = {}));
 var TernaryNode;
 (function (TernaryNode) {
-    function create(ifExpr, testExpr, elseExpr) {
+    function create(key, ifExpr, testExpr, elseExpr) {
         const node = {
             start: ifExpr.start,
             length: ifExpr.length,
             nodeType: 51 /* ParseNodeType.Ternary */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 ifExpr,
                 testExpr,
@@ -903,14 +927,14 @@ var TernaryNode;
 })(TernaryNode || (exports.TernaryNode = TernaryNode = {}));
 var UnpackNode;
 (function (UnpackNode) {
-    function create(starToken, expr) {
+    function create(key, starToken, expr) {
         const node = {
             start: starToken.start,
             length: starToken.length,
             nodeType: 56 /* ParseNodeType.Unpack */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 expr,
                 starToken,
@@ -924,14 +948,14 @@ var UnpackNode;
 })(UnpackNode || (exports.UnpackNode = UnpackNode = {}));
 var TupleNode;
 (function (TupleNode) {
-    function create(range, hasParens) {
+    function create(key, range, hasParens) {
         const node = {
             start: range.start,
             length: range.length,
             nodeType: 52 /* ParseNodeType.Tuple */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 items: [],
                 hasParens,
@@ -943,14 +967,14 @@ var TupleNode;
 })(TupleNode || (exports.TupleNode = TupleNode = {}));
 var CallNode;
 (function (CallNode) {
-    function create(leftExpr, args, trailingComma) {
+    function create(key, leftExpr, args, trailingComma) {
         const node = {
             start: leftExpr.start,
             length: leftExpr.length,
             nodeType: 9 /* ParseNodeType.Call */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 leftExpr,
                 args,
@@ -970,14 +994,14 @@ var CallNode;
 })(CallNode || (exports.CallNode = CallNode = {}));
 var ComprehensionNode;
 (function (ComprehensionNode) {
-    function create(expr, isGenerator) {
+    function create(key, expr, isGenerator) {
         const node = {
             start: expr.start,
             length: expr.length,
             nodeType: 11 /* ParseNodeType.Comprehension */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 expr,
                 forIfNodes: [],
@@ -992,14 +1016,14 @@ var ComprehensionNode;
 })(ComprehensionNode || (exports.ComprehensionNode = ComprehensionNode = {}));
 var IndexNode;
 (function (IndexNode) {
-    function create(leftExpr, items, trailingComma, closeBracketToken) {
+    function create(key, leftExpr, items, trailingComma, closeBracketToken) {
         const node = {
             start: leftExpr.start,
             length: leftExpr.length,
             nodeType: 27 /* ParseNodeType.Index */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 leftExpr,
                 items,
@@ -1017,14 +1041,14 @@ var IndexNode;
 })(IndexNode || (exports.IndexNode = IndexNode = {}));
 var SliceNode;
 (function (SliceNode) {
-    function create(range) {
+    function create(key, range) {
         const node = {
             start: range.start,
             length: range.length,
             nodeType: 46 /* ParseNodeType.Slice */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {},
         };
         return node;
@@ -1033,14 +1057,14 @@ var SliceNode;
 })(SliceNode || (exports.SliceNode = SliceNode = {}));
 var YieldNode;
 (function (YieldNode) {
-    function create(yieldToken, expr) {
+    function create(key, yieldToken, expr) {
         const node = {
             start: yieldToken.start,
             length: yieldToken.length,
             nodeType: 60 /* ParseNodeType.Yield */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: { expr },
         };
         if (expr) {
@@ -1053,14 +1077,14 @@ var YieldNode;
 })(YieldNode || (exports.YieldNode = YieldNode = {}));
 var YieldFromNode;
 (function (YieldFromNode) {
-    function create(yieldToken, expr) {
+    function create(key, yieldToken, expr) {
         const node = {
             start: yieldToken.start,
             length: yieldToken.length,
             nodeType: 61 /* ParseNodeType.YieldFrom */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: { expr },
         };
         expr.parent = node;
@@ -1071,14 +1095,14 @@ var YieldFromNode;
 })(YieldFromNode || (exports.YieldFromNode = YieldFromNode = {}));
 var MemberAccessNode;
 (function (MemberAccessNode) {
-    function create(leftExpr, member) {
+    function create(key, leftExpr, member) {
         const node = {
             start: leftExpr.start,
             length: leftExpr.length,
             nodeType: 35 /* ParseNodeType.MemberAccess */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 leftExpr: leftExpr,
                 member: member,
@@ -1093,14 +1117,14 @@ var MemberAccessNode;
 })(MemberAccessNode || (exports.MemberAccessNode = MemberAccessNode = {}));
 var LambdaNode;
 (function (LambdaNode) {
-    function create(lambdaToken, expr) {
+    function create(key, lambdaToken, expr) {
         const node = {
             start: lambdaToken.start,
             length: lambdaToken.length,
             nodeType: 33 /* ParseNodeType.Lambda */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 params: [],
                 expr,
@@ -1114,14 +1138,14 @@ var LambdaNode;
 })(LambdaNode || (exports.LambdaNode = LambdaNode = {}));
 var NameNode;
 (function (NameNode) {
-    function create(nameToken) {
+    function create(key, nameToken) {
         const node = {
             start: nameToken.start,
             length: nameToken.length,
             nodeType: 38 /* ParseNodeType.Name */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 token: nameToken,
                 value: nameToken.value,
@@ -1133,14 +1157,14 @@ var NameNode;
 })(NameNode || (exports.NameNode = NameNode = {}));
 var ConstantNode;
 (function (ConstantNode) {
-    function create(token) {
+    function create(key, token) {
         const node = {
             start: token.start,
             length: token.length,
             nodeType: 14 /* ParseNodeType.Constant */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: { constType: token.keywordType },
         };
         return node;
@@ -1149,14 +1173,14 @@ var ConstantNode;
 })(ConstantNode || (exports.ConstantNode = ConstantNode = {}));
 var EllipsisNode;
 (function (EllipsisNode) {
-    function create(range) {
+    function create(key, range) {
         const node = {
             start: range.start,
             length: range.length,
             nodeType: 21 /* ParseNodeType.Ellipsis */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {},
         };
         return node;
@@ -1165,14 +1189,14 @@ var EllipsisNode;
 })(EllipsisNode || (exports.EllipsisNode = EllipsisNode = {}));
 var NumberNode;
 (function (NumberNode) {
-    function create(token) {
+    function create(key, token) {
         const node = {
             start: token.start,
             length: token.length,
             nodeType: 40 /* ParseNodeType.Number */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 value: token.value,
                 isInteger: token.isInteger,
@@ -1185,14 +1209,14 @@ var NumberNode;
 })(NumberNode || (exports.NumberNode = NumberNode = {}));
 var StringNode;
 (function (StringNode) {
-    function create(token, value) {
+    function create(key, token, value) {
         const node = {
             start: token.start,
             length: token.length,
             nodeType: 49 /* ParseNodeType.String */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 token,
                 value,
@@ -1204,14 +1228,14 @@ var StringNode;
 })(StringNode || (exports.StringNode = StringNode = {}));
 var FormatStringNode;
 (function (FormatStringNode) {
-    function create(startToken, endToken, middleTokens, fieldExprs, formatExprs) {
+    function create(key, startToken, endToken, middleTokens, fieldExprs, formatExprs) {
         const node = {
             start: startToken.start,
             length: startToken.length,
             nodeType: 30 /* ParseNodeType.FormatString */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 token: startToken,
                 middleTokens,
@@ -1239,17 +1263,16 @@ var FormatStringNode;
 })(FormatStringNode || (exports.FormatStringNode = FormatStringNode = {}));
 var StringListNode;
 (function (StringListNode) {
-    function create(strings) {
+    function create(key, strings) {
         const node = {
             start: strings[0].start,
             length: strings[0].length,
             nodeType: 48 /* ParseNodeType.StringList */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 strings,
-                annotation: undefined,
                 hasParens: false,
             },
         };
@@ -1265,14 +1288,14 @@ var StringListNode;
 })(StringListNode || (exports.StringListNode = StringListNode = {}));
 var DictionaryNode;
 (function (DictionaryNode) {
-    function create(range) {
+    function create(key, range) {
         const node = {
             start: range.start,
             length: range.length,
             nodeType: 18 /* ParseNodeType.Dictionary */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 items: [],
                 trailingCommaToken: undefined,
@@ -1284,14 +1307,14 @@ var DictionaryNode;
 })(DictionaryNode || (exports.DictionaryNode = DictionaryNode = {}));
 var DictionaryKeyEntryNode;
 (function (DictionaryKeyEntryNode) {
-    function create(keyExpr, valueExpr) {
+    function create(key, keyExpr, valueExpr) {
         const node = {
             start: keyExpr.start,
             length: keyExpr.length,
             nodeType: 20 /* ParseNodeType.DictionaryKeyEntry */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 keyExpr,
                 valueExpr,
@@ -1306,14 +1329,14 @@ var DictionaryKeyEntryNode;
 })(DictionaryKeyEntryNode || (exports.DictionaryKeyEntryNode = DictionaryKeyEntryNode = {}));
 var DictionaryExpandEntryNode;
 (function (DictionaryExpandEntryNode) {
-    function create(expr) {
+    function create(key, expr) {
         const node = {
             start: expr.start,
             length: expr.length,
             nodeType: 19 /* ParseNodeType.DictionaryExpandEntry */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: { expr },
         };
         expr.parent = node;
@@ -1323,14 +1346,14 @@ var DictionaryExpandEntryNode;
 })(DictionaryExpandEntryNode || (exports.DictionaryExpandEntryNode = DictionaryExpandEntryNode = {}));
 var SetNode;
 (function (SetNode) {
-    function create(range) {
+    function create(key, range) {
         const node = {
             start: range.start,
             length: range.length,
             nodeType: 45 /* ParseNodeType.Set */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: { items: [] },
         };
         return node;
@@ -1339,14 +1362,14 @@ var SetNode;
 })(SetNode || (exports.SetNode = SetNode = {}));
 var ListNode;
 (function (ListNode) {
-    function create(range) {
+    function create(key, range) {
         const node = {
             start: range.start,
             length: range.length,
             nodeType: 34 /* ParseNodeType.List */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: { items: [] },
         };
         return node;
@@ -1361,14 +1384,14 @@ var ArgCategory;
 })(ArgCategory || (exports.ArgCategory = ArgCategory = {}));
 var ArgumentNode;
 (function (ArgumentNode) {
-    function create(startToken, valueExpr, argCategory) {
+    function create(key, startToken, valueExpr, argCategory) {
         const node = {
             start: startToken ? startToken.start : valueExpr.start,
             length: startToken ? startToken.length : valueExpr.length,
             nodeType: 1 /* ParseNodeType.Argument */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 argCategory,
                 name: undefined,
@@ -1383,14 +1406,14 @@ var ArgumentNode;
 })(ArgumentNode || (exports.ArgumentNode = ArgumentNode = {}));
 var DelNode;
 (function (DelNode) {
-    function create(delToken) {
+    function create(key, delToken) {
         const node = {
             start: delToken.start,
             length: delToken.length,
             nodeType: 17 /* ParseNodeType.Del */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: { targets: [] },
         };
         return node;
@@ -1399,14 +1422,14 @@ var DelNode;
 })(DelNode || (exports.DelNode = DelNode = {}));
 var PassNode;
 (function (PassNode) {
-    function create(passToken) {
+    function create(key, passToken) {
         const node = {
             start: passToken.start,
             length: passToken.length,
             nodeType: 42 /* ParseNodeType.Pass */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {},
         };
         return node;
@@ -1415,14 +1438,14 @@ var PassNode;
 })(PassNode || (exports.PassNode = PassNode = {}));
 var ImportNode;
 (function (ImportNode) {
-    function create(importToken) {
+    function create(key, importToken) {
         const node = {
             start: importToken.start,
             length: importToken.length,
             nodeType: 23 /* ParseNodeType.Import */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: { list: [] },
         };
         return node;
@@ -1431,14 +1454,14 @@ var ImportNode;
 })(ImportNode || (exports.ImportNode = ImportNode = {}));
 var ModuleNameNode;
 (function (ModuleNameNode) {
-    function create(range) {
+    function create(key, range) {
         const node = {
             start: range.start,
             length: range.length,
             nodeType: 37 /* ParseNodeType.ModuleName */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 leadingDots: 0,
                 nameParts: [],
@@ -1450,14 +1473,14 @@ var ModuleNameNode;
 })(ModuleNameNode || (exports.ModuleNameNode = ModuleNameNode = {}));
 var ImportAsNode;
 (function (ImportAsNode) {
-    function create(module) {
+    function create(key, module) {
         const node = {
             start: module.start,
             length: module.length,
             nodeType: 24 /* ParseNodeType.ImportAs */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: { module: module },
         };
         module.parent = node;
@@ -1467,14 +1490,14 @@ var ImportAsNode;
 })(ImportAsNode || (exports.ImportAsNode = ImportAsNode = {}));
 var ImportFromNode;
 (function (ImportFromNode) {
-    function create(fromToken, module) {
+    function create(key, fromToken, module) {
         const node = {
             start: fromToken.start,
             length: fromToken.length,
             nodeType: 25 /* ParseNodeType.ImportFrom */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 module,
                 imports: [],
@@ -1490,14 +1513,14 @@ var ImportFromNode;
 })(ImportFromNode || (exports.ImportFromNode = ImportFromNode = {}));
 var ImportFromAsNode;
 (function (ImportFromAsNode) {
-    function create(name) {
+    function create(key, name) {
         const node = {
             start: name.start,
             length: name.length,
             nodeType: 26 /* ParseNodeType.ImportFromAs */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: { name: name },
         };
         name.parent = node;
@@ -1507,14 +1530,14 @@ var ImportFromAsNode;
 })(ImportFromAsNode || (exports.ImportFromAsNode = ImportFromAsNode = {}));
 var GlobalNode;
 (function (GlobalNode) {
-    function create(range) {
+    function create(key, range) {
         const node = {
             start: range.start,
             length: range.length,
             nodeType: 32 /* ParseNodeType.Global */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: { targets: [] },
         };
         return node;
@@ -1523,14 +1546,14 @@ var GlobalNode;
 })(GlobalNode || (exports.GlobalNode = GlobalNode = {}));
 var NonlocalNode;
 (function (NonlocalNode) {
-    function create(range) {
+    function create(key, range) {
         const node = {
             start: range.start,
             length: range.length,
             nodeType: 39 /* ParseNodeType.Nonlocal */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: { targets: [] },
         };
         return node;
@@ -1539,14 +1562,14 @@ var NonlocalNode;
 })(NonlocalNode || (exports.NonlocalNode = NonlocalNode = {}));
 var AssertNode;
 (function (AssertNode) {
-    function create(assertToken, testExpr) {
+    function create(key, assertToken, testExpr) {
         const node = {
             start: assertToken.start,
             length: assertToken.length,
             nodeType: 2 /* ParseNodeType.Assert */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: { testExpr },
         };
         testExpr.parent = node;
@@ -1557,14 +1580,14 @@ var AssertNode;
 })(AssertNode || (exports.AssertNode = AssertNode = {}));
 var BreakNode;
 (function (BreakNode) {
-    function create(range) {
+    function create(key, range) {
         const node = {
             start: range.start,
             length: range.length,
             nodeType: 8 /* ParseNodeType.Break */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {},
         };
         return node;
@@ -1573,14 +1596,14 @@ var BreakNode;
 })(BreakNode || (exports.BreakNode = BreakNode = {}));
 var ContinueNode;
 (function (ContinueNode) {
-    function create(range) {
+    function create(key, range) {
         const node = {
             start: range.start,
             length: range.length,
             nodeType: 15 /* ParseNodeType.Continue */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {},
         };
         return node;
@@ -1589,14 +1612,14 @@ var ContinueNode;
 })(ContinueNode || (exports.ContinueNode = ContinueNode = {}));
 var ReturnNode;
 (function (ReturnNode) {
-    function create(range) {
+    function create(key, range) {
         const node = {
             start: range.start,
             length: range.length,
             nodeType: 44 /* ParseNodeType.Return */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {},
         };
         return node;
@@ -1605,14 +1628,14 @@ var ReturnNode;
 })(ReturnNode || (exports.ReturnNode = ReturnNode = {}));
 var RaiseNode;
 (function (RaiseNode) {
-    function create(range) {
+    function create(key, range) {
         const node = {
             start: range.start,
             length: range.length,
             nodeType: 43 /* ParseNodeType.Raise */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {},
         };
         return node;
@@ -1621,14 +1644,14 @@ var RaiseNode;
 })(RaiseNode || (exports.RaiseNode = RaiseNode = {}));
 var MatchNode;
 (function (MatchNode) {
-    function create(matchToken, expr) {
+    function create(key, matchToken, expr) {
         const node = {
             start: matchToken.start,
             length: matchToken.length,
             nodeType: 63 /* ParseNodeType.Match */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 firstToken: matchToken,
                 expr,
@@ -1643,14 +1666,14 @@ var MatchNode;
 })(MatchNode || (exports.MatchNode = MatchNode = {}));
 var CaseNode;
 (function (CaseNode) {
-    function create(caseToken, pattern, isIrrefutable, guardExpr, suite) {
+    function create(key, caseToken, pattern, isIrrefutable, guardExpr, suite) {
         const node = {
             start: caseToken.start,
             length: caseToken.length,
             nodeType: 64 /* ParseNodeType.Case */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 pattern,
                 isIrrefutable,
@@ -1670,7 +1693,7 @@ var CaseNode;
 })(CaseNode || (exports.CaseNode = CaseNode = {}));
 var PatternSequenceNode;
 (function (PatternSequenceNode) {
-    function create(firstToken, entries) {
+    function create(key, firstToken, entries) {
         const starEntryIndex = entries.findIndex((entry) => entry.d.orPatterns.length === 1 &&
             entry.d.orPatterns[0].nodeType === 69 /* ParseNodeType.PatternCapture */ &&
             entry.d.orPatterns[0].d.isStar);
@@ -1680,7 +1703,7 @@ var PatternSequenceNode;
             nodeType: 65 /* ParseNodeType.PatternSequence */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 entries,
                 starEntryIndex: starEntryIndex >= 0 ? starEntryIndex : undefined,
@@ -1698,14 +1721,14 @@ var PatternSequenceNode;
 })(PatternSequenceNode || (exports.PatternSequenceNode = PatternSequenceNode = {}));
 var PatternAsNode;
 (function (PatternAsNode) {
-    function create(orPatterns, target) {
+    function create(key, orPatterns, target) {
         const node = {
             start: orPatterns[0].start,
             length: orPatterns[0].length,
             nodeType: 66 /* ParseNodeType.PatternAs */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 orPatterns,
                 target,
@@ -1727,14 +1750,14 @@ var PatternAsNode;
 })(PatternAsNode || (exports.PatternAsNode = PatternAsNode = {}));
 var PatternLiteralNode;
 (function (PatternLiteralNode) {
-    function create(expr) {
+    function create(key, expr) {
         const node = {
             start: expr.start,
             length: expr.length,
             nodeType: 67 /* ParseNodeType.PatternLiteral */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: { expr },
         };
         expr.parent = node;
@@ -1744,14 +1767,14 @@ var PatternLiteralNode;
 })(PatternLiteralNode || (exports.PatternLiteralNode = PatternLiteralNode = {}));
 var PatternClassNode;
 (function (PatternClassNode) {
-    function create(className, args) {
+    function create(key, className, args) {
         const node = {
             start: className.start,
             length: className.length,
             nodeType: 68 /* ParseNodeType.PatternClass */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 className,
                 args,
@@ -1770,14 +1793,14 @@ var PatternClassNode;
 })(PatternClassNode || (exports.PatternClassNode = PatternClassNode = {}));
 var PatternClassArgumentNode;
 (function (PatternClassArgumentNode) {
-    function create(pattern, name) {
+    function create(key, pattern, name) {
         const node = {
             start: pattern.start,
             length: pattern.length,
             nodeType: 74 /* ParseNodeType.PatternClassArgument */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 pattern,
                 name,
@@ -1794,14 +1817,14 @@ var PatternClassArgumentNode;
 })(PatternClassArgumentNode || (exports.PatternClassArgumentNode = PatternClassArgumentNode = {}));
 var PatternCaptureNode;
 (function (PatternCaptureNode) {
-    function create(target, starToken) {
+    function create(key, target, starToken) {
         const node = {
             start: target.start,
             length: target.length,
             nodeType: 69 /* ParseNodeType.PatternCapture */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 target,
                 isStar: starToken !== undefined,
@@ -1818,14 +1841,14 @@ var PatternCaptureNode;
 })(PatternCaptureNode || (exports.PatternCaptureNode = PatternCaptureNode = {}));
 var PatternMappingNode;
 (function (PatternMappingNode) {
-    function create(startToken, entries) {
+    function create(key, startToken, entries) {
         const node = {
             start: startToken.start,
             length: startToken.length,
             nodeType: 70 /* ParseNodeType.PatternMapping */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: { entries },
         };
         if (entries.length > 0) {
@@ -1840,14 +1863,14 @@ var PatternMappingNode;
 })(PatternMappingNode || (exports.PatternMappingNode = PatternMappingNode = {}));
 var PatternMappingKeyEntryNode;
 (function (PatternMappingKeyEntryNode) {
-    function create(keyPattern, valuePattern) {
+    function create(key, keyPattern, valuePattern) {
         const node = {
             start: keyPattern.start,
             length: keyPattern.length,
             nodeType: 71 /* ParseNodeType.PatternMappingKeyEntry */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: {
                 keyPattern,
                 valuePattern,
@@ -1862,14 +1885,14 @@ var PatternMappingKeyEntryNode;
 })(PatternMappingKeyEntryNode || (exports.PatternMappingKeyEntryNode = PatternMappingKeyEntryNode = {}));
 var PatternMappingExpandEntryNode;
 (function (PatternMappingExpandEntryNode) {
-    function create(starStarToken, target) {
+    function create(key, starStarToken, target) {
         const node = {
             start: starStarToken.start,
             length: starStarToken.length,
             nodeType: 72 /* ParseNodeType.PatternMappingExpandEntry */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: { target },
         };
         target.parent = node;
@@ -1880,14 +1903,14 @@ var PatternMappingExpandEntryNode;
 })(PatternMappingExpandEntryNode || (exports.PatternMappingExpandEntryNode = PatternMappingExpandEntryNode = {}));
 var PatternValueNode;
 (function (PatternValueNode) {
-    function create(expr) {
+    function create(key, expr) {
         const node = {
             start: expr.start,
             length: expr.length,
             nodeType: 73 /* ParseNodeType.PatternValue */,
             id: _nextNodeId++,
             parent: undefined,
-            a: undefined,
+            a: key,
             d: { expr },
         };
         expr.parent = node;