@zzzen/pyright-internal 1.2.0-dev.20240707 → 1.2.0-dev.20240721

package/dist/parser/parser.js

@@ -87,6 +87,7 @@ class Parser {
         this._assignmentExpressionsAllowed = true;
         this._typingImportAliases = [];
         this._typingSymbolAliases = new Map();
+        this._maxChildDepthMap = new Map();
     }
     parseSourceFile(fileContents, parseOptions, diagSink) {
         timing_1.timingStats.tokenizeFileTime.timeOperation(() => {
@@ -115,7 +116,7 @@ class Parser {
                     }
                     else {
                         statement.parent = moduleNode;
-                        moduleNode.statements.push(statement);
+                        moduleNode.d.statements.push(statement);
                     }
                 }
             }
@@ -323,12 +324,12 @@ class Parser {
     }
     // type_param: ['*' | '**'] NAME [':' bound_expr] ['=' default_expr]
     _parseTypeParameter() {
-        let typeParamCategory = parseNodes_1.TypeParameterCategory.TypeVar;
+        let typeParamCategory = parseNodes_1.TypeParameterKind.TypeVar;
         if (this._consumeTokenIfOperator(26 /* OperatorType.Multiply */)) {
-            typeParamCategory = parseNodes_1.TypeParameterCategory.TypeVarTuple;
+            typeParamCategory = parseNodes_1.TypeParameterKind.TypeVarTuple;
         }
         else if (this._consumeTokenIfOperator(29 /* OperatorType.Power */)) {
-            typeParamCategory = parseNodes_1.TypeParameterCategory.ParamSpec;
+            typeParamCategory = parseNodes_1.TypeParameterKind.ParamSpec;
         }
         const nameToken = this._getTokenIfIdentifier();
         if (!nameToken) {
@@ -339,14 +340,14 @@ class Parser {
         let boundExpression;
         if (this._consumeTokenIfType(10 /* TokenType.Colon */)) {
             boundExpression = this._parseExpression(/* allowUnpack */ false);
-            if (typeParamCategory !== parseNodes_1.TypeParameterCategory.TypeVar) {
+            if (typeParamCategory !== parseNodes_1.TypeParameterKind.TypeVar) {
                 this._addSyntaxError(localize_1.LocMessage.typeParameterBoundNotAllowed(), boundExpression);
             }
         }
         let defaultExpression;
         if (this._consumeTokenIfOperator(2 /* OperatorType.Assign */)) {
             defaultExpression = this._parseExpression(
-            /* allowUnpack */ typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVarTuple);
+            /* allowUnpack */ typeParamCategory === parseNodes_1.TypeParameterKind.TypeVarTuple);
             if (!this._parseOptions.isStubFile && this._getLanguageVersion().isLessThan(pythonVersion_1.pythonVersion3_13)) {
                 this._addSyntaxError(localize_1.LocMessage.typeVarDefaultIllegal(), defaultExpression);
             }
@@ -430,7 +431,7 @@ class Parser {
                     }
                     else {
                         caseStatement.parent = matchNode;
-                        matchNode.cases.push(caseStatement);
+                        matchNode.d.cases.push(caseStatement);
                     }
                     const dedentToken = this._peekToken();
                     if (this._consumeTokenIfType(4 /* TokenType.Dedent */)) {
@@ -447,8 +448,8 @@ class Parser {
                     }
                 }
             }
-            if (matchNode.cases.length > 0) {
-                (0, parseNodes_1.extendRange)(matchNode, matchNode.cases[matchNode.cases.length - 1]);
+            if (matchNode.d.cases.length > 0) {
+                (0, parseNodes_1.extendRange)(matchNode, matchNode.d.cases[matchNode.d.cases.length - 1]);
             }
             else {
                 this._addSyntaxError(localize_1.LocMessage.zeroCaseStatementsFound(), matchToken);
@@ -459,10 +460,10 @@ class Parser {
             this._addSyntaxError(localize_1.LocMessage.matchIncompatible(), matchToken);
         }
         // Validate that only the last entry uses an irrefutable pattern.
-        for (let i = 0; i < matchNode.cases.length - 1; i++) {
-            const caseNode = matchNode.cases[i];
-            if (!caseNode.guardExpression && caseNode.isIrrefutable) {
-                this._addSyntaxError(localize_1.LocMessage.casePatternIsIrrefutable(), caseNode.pattern);
+        for (let i = 0; i < matchNode.d.cases.length - 1; i++) {
+            const caseNode = matchNode.d.cases[i];
+            if (!caseNode.d.guardExpr && caseNode.d.isIrrefutable) {
+                this._addSyntaxError(localize_1.LocMessage.casePatternIsIrrefutable(), caseNode.d.pattern);
             }
         }
         return matchNode;
@@ -486,8 +487,8 @@ class Parser {
             casePattern = parseNodes_1.ErrorNode.create(caseToken, 11 /* ErrorExpressionCategory.MissingPattern */);
         }
         else if (patternList.list.length === 1 && !patternList.trailingComma) {
-            const pattern = patternList.list[0].orPatterns[0];
-            if (pattern.nodeType === 69 /* ParseNodeType.PatternCapture */ && pattern.isStar) {
+            const pattern = patternList.list[0].d.orPatterns[0];
+            if (pattern.nodeType === 69 /* ParseNodeType.PatternCapture */ && pattern.d.isStar) {
                 casePattern = parseNodes_1.PatternSequenceNode.create(patternList.list[0], patternList.list);
             }
             else {
@@ -516,7 +517,7 @@ class Parser {
             return true;
         }
         if (node.nodeType === 66 /* ParseNodeType.PatternAs */) {
-            return node.orPatterns.some((pattern) => this._isPatternIrrefutable(pattern));
+            return node.d.orPatterns.some((pattern) => this._isPatternIrrefutable(pattern));
         }
         return false;
     }
@@ -526,33 +527,33 @@ class Parser {
     // as well as the targets we've seen locally within the current "or" clause.
     _reportDuplicatePatternCaptureTargets(node, globalNameMap, localNameMap) {
         const reportTargetIfDuplicate = (nameNode) => {
-            if (globalNameMap.has(nameNode.value) || localNameMap.has(nameNode.value)) {
+            if (globalNameMap.has(nameNode.d.value) || localNameMap.has(nameNode.d.value)) {
                 this._addSyntaxError(localize_1.LocMessage.duplicateCapturePatternTarget().format({
-                    name: nameNode.value,
+                    name: nameNode.d.value,
                 }), nameNode);
             }
             else {
-                localNameMap.set(nameNode.value, nameNode);
+                localNameMap.set(nameNode.d.value, nameNode);
             }
         };
         switch (node.nodeType) {
             case 65 /* ParseNodeType.PatternSequence */: {
-                node.entries.forEach((subpattern) => {
+                node.d.entries.forEach((subpattern) => {
                     this._reportDuplicatePatternCaptureTargets(subpattern, globalNameMap, localNameMap);
                 });
                 break;
             }
             case 68 /* ParseNodeType.PatternClass */: {
-                node.arguments.forEach((arg) => {
-                    this._reportDuplicatePatternCaptureTargets(arg.pattern, globalNameMap, localNameMap);
+                node.d.args.forEach((arg) => {
+                    this._reportDuplicatePatternCaptureTargets(arg.d.pattern, globalNameMap, localNameMap);
                 });
                 break;
             }
             case 66 /* ParseNodeType.PatternAs */: {
-                if (node.target) {
-                    reportTargetIfDuplicate(node.target);
+                if (node.d.target) {
+                    reportTargetIfDuplicate(node.d.target);
                 }
-                const orLocalNameMaps = node.orPatterns.map((subpattern) => {
+                const orLocalNameMaps = node.d.orPatterns.map((subpattern) => {
                     const orLocalNameMap = new Map();
                     this._reportDuplicatePatternCaptureTargets(subpattern, localNameMap, orLocalNameMap);
                     return orLocalNameMap;
@@ -560,8 +561,8 @@ class Parser {
                 const combinedLocalOrNameMap = new Map();
                 orLocalNameMaps.forEach((orLocalNameMap) => {
                     orLocalNameMap.forEach((node) => {
-                        if (!combinedLocalOrNameMap.has(node.value)) {
-                            combinedLocalOrNameMap.set(node.value, node);
+                        if (!combinedLocalOrNameMap.has(node.d.value)) {
+                            combinedLocalOrNameMap.set(node.d.value, node);
                             reportTargetIfDuplicate(node);
                         }
                     });
@@ -569,19 +570,19 @@ class Parser {
                 break;
             }
             case 69 /* ParseNodeType.PatternCapture */: {
-                if (!node.isWildcard) {
-                    reportTargetIfDuplicate(node.target);
+                if (!node.d.isWildcard) {
+                    reportTargetIfDuplicate(node.d.target);
                 }
                 break;
             }
             case 70 /* ParseNodeType.PatternMapping */: {
-                node.entries.forEach((mapEntry) => {
+                node.d.entries.forEach((mapEntry) => {
                     if (mapEntry.nodeType === 72 /* ParseNodeType.PatternMappingExpandEntry */) {
-                        reportTargetIfDuplicate(mapEntry.target);
+                        reportTargetIfDuplicate(mapEntry.d.target);
                     }
                     else {
-                        this._reportDuplicatePatternCaptureTargets(mapEntry.keyPattern, globalNameMap, localNameMap);
-                        this._reportDuplicatePatternCaptureTargets(mapEntry.valuePattern, globalNameMap, localNameMap);
+                        this._reportDuplicatePatternCaptureTargets(mapEntry.d.keyPattern, globalNameMap, localNameMap);
+                        this._reportDuplicatePatternCaptureTargets(mapEntry.d.valuePattern, globalNameMap, localNameMap);
                     }
                 });
                 break;
@@ -596,40 +597,40 @@ class Parser {
     _getPatternTargetNames(node, nameSet) {
         switch (node.nodeType) {
             case 65 /* ParseNodeType.PatternSequence */: {
-                node.entries.forEach((subpattern) => {
+                node.d.entries.forEach((subpattern) => {
                     this._getPatternTargetNames(subpattern, nameSet);
                 });
                 break;
             }
             case 68 /* ParseNodeType.PatternClass */: {
-                node.arguments.forEach((arg) => {
-                    this._getPatternTargetNames(arg.pattern, nameSet);
+                node.d.args.forEach((arg) => {
+                    this._getPatternTargetNames(arg.d.pattern, nameSet);
                 });
                 break;
             }
             case 66 /* ParseNodeType.PatternAs */: {
-                if (node.target) {
-                    nameSet.add(node.target.value);
+                if (node.d.target) {
+                    nameSet.add(node.d.target.d.value);
                 }
-                node.orPatterns.forEach((subpattern) => {
+                node.d.orPatterns.forEach((subpattern) => {
                     this._getPatternTargetNames(subpattern, nameSet);
                 });
                 break;
             }
             case 69 /* ParseNodeType.PatternCapture */: {
-                if (!node.isWildcard) {
-                    nameSet.add(node.target.value);
+                if (!node.d.isWildcard) {
+                    nameSet.add(node.d.target.d.value);
                 }
                 break;
             }
             case 70 /* ParseNodeType.PatternMapping */: {
-                node.entries.forEach((mapEntry) => {
+                node.d.entries.forEach((mapEntry) => {
                     if (mapEntry.nodeType === 72 /* ParseNodeType.PatternMappingExpandEntry */) {
-                        nameSet.add(mapEntry.target.value);
+                        nameSet.add(mapEntry.d.target.d.value);
                     }
                     else {
-                        this._getPatternTargetNames(mapEntry.keyPattern, nameSet);
-                        this._getPatternTargetNames(mapEntry.valuePattern, nameSet);
+                        this._getPatternTargetNames(mapEntry.d.keyPattern, nameSet);
+                        this._getPatternTargetNames(mapEntry.d.valuePattern, nameSet);
                     }
                 });
                 break;
@@ -644,11 +645,11 @@ class Parser {
     _parsePatternSequence() {
         const patternList = this._parseExpressionListGeneric(() => this._parsePatternAs());
         // Check for more than one star entry.
-        const starEntries = patternList.list.filter((entry) => entry.orPatterns.length === 1 &&
-            entry.orPatterns[0].nodeType === 69 /* ParseNodeType.PatternCapture */ &&
-            entry.orPatterns[0].isStar);
+        const starEntries = patternList.list.filter((entry) => entry.d.orPatterns.length === 1 &&
+            entry.d.orPatterns[0].nodeType === 69 /* ParseNodeType.PatternCapture */ &&
+            entry.d.orPatterns[0].d.isStar);
         if (starEntries.length > 1) {
-            this._addSyntaxError(localize_1.LocMessage.duplicateStarPattern(), starEntries[1].orPatterns[0]);
+            this._addSyntaxError(localize_1.LocMessage.duplicateStarPattern(), starEntries[1].d.orPatterns[0]);
         }
         return patternList;
     }
@@ -666,7 +667,7 @@ class Parser {
         if (orPatterns.length > 1) {
             // Star patterns cannot be ORed with other patterns.
             orPatterns.forEach((patternAtom) => {
-                if (patternAtom.nodeType === 69 /* ParseNodeType.PatternCapture */ && patternAtom.isStar) {
+                if (patternAtom.nodeType === 69 /* ParseNodeType.PatternCapture */ && patternAtom.d.isStar) {
                     this._addSyntaxError(localize_1.LocMessage.starPatternInOrPattern(), patternAtom);
                 }
             });
@@ -685,7 +686,7 @@ class Parser {
         if (target &&
             orPatterns.length === 1 &&
             orPatterns[0].nodeType === 69 /* ParseNodeType.PatternCapture */ &&
-            orPatterns[0].isStar) {
+            orPatterns[0].d.isStar) {
             this._addSyntaxError(localize_1.LocMessage.starPatternInAsPattern(), orPatterns[0]);
         }
         // Validate that irrefutable patterns are not in any entries other than the last.
@@ -740,8 +741,8 @@ class Parser {
             }
             const args = this._parseClassPatternArgList();
             const classNameExpr = patternCaptureOrValue.nodeType === 69 /* ParseNodeType.PatternCapture */
-                ? patternCaptureOrValue.target
-                : patternCaptureOrValue.expression;
+                ? patternCaptureOrValue.d.target
+                : patternCaptureOrValue.d.expr;
             const classPattern = parseNodes_1.PatternClassNode.create(classNameExpr, args);
             if (!this._consumeTokenIfType(14 /* TokenType.CloseParenthesis */)) {
                 this._addSyntaxError(localize_1.LocMessage.expectedCloseParen(), openParenToken);
@@ -777,8 +778,8 @@ class Parser {
             else if (patternList.list.length === 1 &&
                 !patternList.trailingComma &&
                 startToken.type === 13 /* TokenType.OpenParenthesis */) {
-                const pattern = patternList.list[0].orPatterns[0];
-                if (pattern.nodeType === 69 /* ParseNodeType.PatternCapture */ && pattern.isStar) {
+                const pattern = patternList.list[0].d.orPatterns[0];
+                if (pattern.nodeType === 69 /* ParseNodeType.PatternCapture */ && pattern.d.isStar) {
                     casePattern = parseNodes_1.PatternSequenceNode.create(startToken, patternList.list);
                 }
                 else {
@@ -835,10 +836,10 @@ class Parser {
                 break;
             }
             const arg = this._parseClassPatternArgument();
-            if (arg.name) {
+            if (arg.d.name) {
                 sawKeywordArg = true;
             }
-            else if (sawKeywordArg && !arg.name) {
+            else if (sawKeywordArg && !arg.d.name) {
                 this._addSyntaxError(localize_1.LocMessage.positionArgAfterNamedArg(), arg);
             }
             argList.push(arg);
@@ -883,7 +884,7 @@ class Parser {
             const stringList = this._parseAtom();
             (0, debug_1.assert)(stringList.nodeType === 48 /* ParseNodeType.StringList */);
             // Check for f-strings, which are not allowed.
-            stringList.strings.forEach((stringAtom) => {
+            stringList.d.strings.forEach((stringAtom) => {
                 if (stringAtom.nodeType === 30 /* ParseNodeType.FormatString */) {
                     this._addSyntaxError(localize_1.LocMessage.formatStringInPattern(), stringAtom);
                 }
@@ -906,28 +907,28 @@ class Parser {
         let realValue;
         let imagValue;
         if (expression.nodeType === 7 /* ParseNodeType.BinaryOperation */) {
-            if (expression.operator === 33 /* OperatorType.Subtract */ || expression.operator === 0 /* OperatorType.Add */) {
-                realValue = expression.leftExpression;
-                imagValue = expression.rightExpression;
+            if (expression.d.operator === 33 /* OperatorType.Subtract */ || expression.d.operator === 0 /* OperatorType.Add */) {
+                realValue = expression.d.leftExpr;
+                imagValue = expression.d.rightExpr;
             }
         }
         else {
             realValue = expression;
         }
         if (realValue) {
-            if (realValue.nodeType === 55 /* ParseNodeType.UnaryOperation */ && realValue.operator === 33 /* OperatorType.Subtract */) {
-                realValue = realValue.expression;
+            if (realValue.nodeType === 55 /* ParseNodeType.UnaryOperation */ && realValue.d.operator === 33 /* OperatorType.Subtract */) {
+                realValue = realValue.d.expr;
             }
-            if (realValue.nodeType !== 40 /* ParseNodeType.Number */ || (imagValue !== undefined && realValue.isImaginary)) {
+            if (realValue.nodeType !== 40 /* ParseNodeType.Number */ || (imagValue !== undefined && realValue.d.isImaginary)) {
                 this._addSyntaxError(localize_1.LocMessage.expectedComplexNumberLiteral(), expression);
                 imagValue = undefined;
             }
         }
         if (imagValue) {
-            if (imagValue.nodeType === 55 /* ParseNodeType.UnaryOperation */ && imagValue.operator === 33 /* OperatorType.Subtract */) {
-                imagValue = imagValue.expression;
+            if (imagValue.nodeType === 55 /* ParseNodeType.UnaryOperation */ && imagValue.d.operator === 33 /* OperatorType.Subtract */) {
+                imagValue = imagValue.d.expr;
             }
-            if (imagValue.nodeType !== 40 /* ParseNodeType.Number */ || !imagValue.isImaginary) {
+            if (imagValue.nodeType !== 40 /* ParseNodeType.Number */ || !imagValue.d.isImaginary) {
                 this._addSyntaxError(localize_1.LocMessage.expectedComplexNumberLiteral(), expression);
             }
         }
@@ -1031,15 +1032,15 @@ class Parser {
         const suite = this._parseSuite(this._isInFunction);
         const ifNode = parseNodes_1.IfNode.create(ifOrElifToken, test, suite);
         if (this._consumeTokenIfKeyword(13 /* KeywordType.Else */)) {
-            ifNode.elseSuite = this._parseSuite(this._isInFunction);
-            ifNode.elseSuite.parent = ifNode;
-            (0, parseNodes_1.extendRange)(ifNode, ifNode.elseSuite);
+            ifNode.d.elseSuite = this._parseSuite(this._isInFunction);
+            ifNode.d.elseSuite.parent = ifNode;
+            (0, parseNodes_1.extendRange)(ifNode, ifNode.d.elseSuite);
         }
         else if (this._peekKeywordType() === 12 /* KeywordType.Elif */) {
             // Recursively handle an "elif" statement.
-            ifNode.elseSuite = this._parseIfStatement(12 /* KeywordType.Elif */);
-            ifNode.elseSuite.parent = ifNode;
-            (0, parseNodes_1.extendRange)(ifNode, ifNode.elseSuite);
+            ifNode.d.elseSuite = this._parseIfStatement(12 /* KeywordType.Elif */);
+            ifNode.d.elseSuite.parent = ifNode;
+            (0, parseNodes_1.extendRange)(ifNode, ifNode.d.elseSuite);
         }
         return ifNode;
     }
@@ -1058,7 +1059,7 @@ class Parser {
         this._isInLoop = wasInLoop;
         this._isInFinally = wasInFinally;
         if (typeComment) {
-            suite.typeComment = typeComment;
+            suite.d.typeComment = typeComment;
         }
         return suite;
     }
@@ -1156,7 +1157,7 @@ class Parser {
                     // recovery. This allows a single dedent token to cause us to break out of
                     // multiple levels of nested suites. Also extend the suite's range in this
                     // case so it is multi-line as this works better with indentationUtils.
-                    if (suite.statements.length > 0) {
+                    if (suite.d.statements.length > 0) {
                         this._consumeTokenIfType(4 /* TokenType.Dedent */);
                     }
                     else {
@@ -1185,7 +1186,7 @@ class Parser {
                 }
                 else {
                     statement.parent = suite;
-                    suite.statements.push(statement);
+                    suite.d.statements.push(statement);
                 }
                 if (this._peekTokenType() === 1 /* TokenType.EndOfStream */) {
                     break;
@@ -1194,11 +1195,11 @@ class Parser {
         }
         else {
             const simpleStatement = this._parseSimpleStatement();
-            suite.statements.push(simpleStatement);
+            suite.d.statements.push(simpleStatement);
             simpleStatement.parent = suite;
         }
-        if (suite.statements.length > 0) {
-            (0, parseNodes_1.extendRange)(suite, suite.statements[suite.statements.length - 1]);
+        if (suite.d.statements.length > 0) {
+            (0, parseNodes_1.extendRange)(suite, suite.d.statements[suite.d.statements.length - 1]);
         }
         this._isInFunction = wasFunction;
         return suite;
@@ -1222,9 +1223,9 @@ class Parser {
             // Versions of Python earlier than 3.9 didn't allow unpack operators if the
             // tuple wasn't enclosed in parentheses.
             if (this._getLanguageVersion().isLessThan(pythonVersion_1.pythonVersion3_9) && !this._parseOptions.isStubFile) {
-                if (seqExpr.nodeType === 52 /* ParseNodeType.Tuple */ && !seqExpr.enclosedInParens) {
+                if (seqExpr.nodeType === 52 /* ParseNodeType.Tuple */ && !seqExpr.d.hasParens) {
                     let sawStar = false;
-                    seqExpr.expressions.forEach((expr) => {
+                    seqExpr.d.items.forEach((expr) => {
                         if (expr.nodeType === 56 /* ParseNodeType.Unpack */ && !sawStar) {
                             this._addSyntaxError(localize_1.LocMessage.unpackOperatorNotAllowed(), expr);
                             sawStar = true;
@@ -1237,18 +1238,18 @@ class Parser {
             }
         }
         const forNode = parseNodes_1.ForNode.create(forToken, targetExpr, seqExpr, forSuite);
-        forNode.elseSuite = elseSuite;
+        forNode.d.elseSuite = elseSuite;
         if (elseSuite) {
             (0, parseNodes_1.extendRange)(forNode, elseSuite);
             elseSuite.parent = forNode;
         }
         if (asyncToken) {
-            forNode.isAsync = true;
-            forNode.asyncToken = asyncToken;
+            forNode.d.isAsync = true;
+            forNode.d.asyncToken = asyncToken;
             (0, parseNodes_1.extendRange)(forNode, asyncToken);
         }
-        if (forSuite.typeComment) {
-            forNode.typeComment = forSuite.typeComment;
+        if (forSuite.d.typeComment) {
+            forNode.d.typeComment = forSuite.d.typeComment;
         }
         return forNode;
     }
@@ -1274,7 +1275,7 @@ class Parser {
             compIter.parent = compNode;
             forIfList.push(compIter);
         }
-        compNode.forIfNodes = forIfList;
+        compNode.d.forIfNodes = forIfList;
         if (forIfList.length > 0) {
             forIfList.forEach((comp) => {
                 comp.parent = compNode;
@@ -1312,8 +1313,8 @@ class Parser {
         }
         const compForNode = parseNodes_1.ComprehensionForNode.create(asyncToken || forToken, targetExpr, seqExpr);
         if (asyncToken) {
-            compForNode.isAsync = true;
-            compForNode.asyncToken = asyncToken;
+            compForNode.d.isAsync = true;
+            compForNode.d.asyncToken = asyncToken;
         }
         return compForNode;
     }
@@ -1334,9 +1335,9 @@ class Parser {
         const whileToken = this._getKeywordToken(36 /* KeywordType.While */);
         const whileNode = parseNodes_1.WhileNode.create(whileToken, this._parseTestExpression(/* allowAssignmentExpression */ true), this._parseLoopSuite());
         if (this._consumeTokenIfKeyword(13 /* KeywordType.Else */)) {
-            whileNode.elseSuite = this._parseSuite(this._isInFunction);
-            whileNode.elseSuite.parent = whileNode;
-            (0, parseNodes_1.extendRange)(whileNode, whileNode.elseSuite);
+            whileNode.d.elseSuite = this._parseSuite(this._isInFunction);
+            whileNode.d.elseSuite.parent = whileNode;
+            (0, parseNodes_1.extendRange)(whileNode, whileNode.d.elseSuite);
         }
         return whileNode;
     }
@@ -1399,30 +1400,30 @@ class Parser {
             const exceptSuite = this._parseSuite(this._isInFunction);
             const exceptNode = parseNodes_1.ExceptNode.create(exceptToken, exceptSuite, isExceptGroup);
             if (typeExpr) {
-                exceptNode.typeExpression = typeExpr;
-                exceptNode.typeExpression.parent = exceptNode;
+                exceptNode.d.typeExpr = typeExpr;
+                exceptNode.d.typeExpr.parent = exceptNode;
             }
             if (symbolName) {
-                exceptNode.name = parseNodes_1.NameNode.create(symbolName);
-                exceptNode.name.parent = exceptNode;
+                exceptNode.d.name = parseNodes_1.NameNode.create(symbolName);
+                exceptNode.d.name.parent = exceptNode;
             }
-            tryNode.exceptClauses.push(exceptNode);
+            tryNode.d.exceptClauses.push(exceptNode);
             exceptNode.parent = tryNode;
         }
-        if (tryNode.exceptClauses.length > 0) {
-            (0, parseNodes_1.extendRange)(tryNode, tryNode.exceptClauses[tryNode.exceptClauses.length - 1]);
+        if (tryNode.d.exceptClauses.length > 0) {
+            (0, parseNodes_1.extendRange)(tryNode, tryNode.d.exceptClauses[tryNode.d.exceptClauses.length - 1]);
             if (this._consumeTokenIfKeyword(13 /* KeywordType.Else */)) {
-                tryNode.elseSuite = this._parseSuite(this._isInFunction);
-                tryNode.elseSuite.parent = tryNode;
-                (0, parseNodes_1.extendRange)(tryNode, tryNode.elseSuite);
+                tryNode.d.elseSuite = this._parseSuite(this._isInFunction);
+                tryNode.d.elseSuite.parent = tryNode;
+                (0, parseNodes_1.extendRange)(tryNode, tryNode.d.elseSuite);
             }
         }
         if (this._consumeTokenIfKeyword(16 /* KeywordType.Finally */)) {
-            tryNode.finallySuite = this._parseSuite(this._isInFunction);
-            tryNode.finallySuite.parent = tryNode;
-            (0, parseNodes_1.extendRange)(tryNode, tryNode.finallySuite);
+            tryNode.d.finallySuite = this._parseSuite(this._isInFunction);
+            tryNode.d.finallySuite.parent = tryNode;
+            (0, parseNodes_1.extendRange)(tryNode, tryNode.d.finallySuite);
         }
-        if (!tryNode.finallySuite && tryNode.exceptClauses.length === 0) {
+        if (!tryNode.d.finallySuite && tryNode.d.exceptClauses.length === 0) {
             this._addSyntaxError(localize_1.LocMessage.tryWithoutExcept(), tryToken);
         }
         return tryNode;
@@ -1466,15 +1467,15 @@ class Parser {
         });
         const functionNode = parseNodes_1.FunctionNode.create(defToken, parseNodes_1.NameNode.create(nameToken), suite, typeParameters);
         if (asyncToken) {
-            functionNode.isAsync = true;
+            functionNode.d.isAsync = true;
             (0, parseNodes_1.extendRange)(functionNode, asyncToken);
         }
-        functionNode.parameters = paramList;
+        functionNode.d.params = paramList;
         paramList.forEach((param) => {
             param.parent = functionNode;
         });
         if (decorators) {
-            functionNode.decorators = decorators;
+            functionNode.d.decorators = decorators;
             decorators.forEach((decorator) => {
                 decorator.parent = functionNode;
             });
@@ -1483,8 +1484,8 @@ class Parser {
             }
         }
         if (returnType) {
-            functionNode.returnTypeAnnotation = returnType;
-            functionNode.returnTypeAnnotation.parent = functionNode;
+            functionNode.d.returnAnnotation = returnType;
+            functionNode.d.returnAnnotation.parent = functionNode;
             (0, parseNodes_1.extendRange)(functionNode, returnType);
         }
         // If there was a type annotation comment for the function,
@@ -1525,22 +1526,22 @@ class Parser {
                 this._consumeTokensUntilType([terminator]);
                 break;
             }
-            if (param.name) {
-                const name = param.name.value;
+            if (param.d.name) {
+                const name = param.d.name.d.value;
                 if (paramMap.has(name)) {
-                    this._addSyntaxError(localize_1.LocMessage.duplicateParam().format({ name }), param.name);
+                    this._addSyntaxError(localize_1.LocMessage.duplicateParam().format({ name }), param.d.name);
                 }
                 else {
                     paramMap.set(name, name);
                 }
             }
-            else if (param.category === 0 /* ParameterCategory.Simple */) {
+            else if (param.d.category === 0 /* ParameterCategory.Simple */) {
                 if (paramList.length === 0) {
                     this._addSyntaxError(localize_1.LocMessage.positionOnlyFirstParam(), param);
                 }
             }
-            if (param.category === 0 /* ParameterCategory.Simple */) {
-                if (!param.name) {
+            if (param.d.category === 0 /* ParameterCategory.Simple */) {
+                if (!param.d.name) {
                     if (sawPositionOnlySeparator) {
                         this._addSyntaxError(localize_1.LocMessage.duplicatePositionOnly(), param);
                     }
@@ -1556,7 +1557,7 @@ class Parser {
                     if (sawKeywordOnlySeparator) {
                         sawKeywordOnlyParamAfterSeparator = true;
                     }
-                    if (param.defaultValue) {
+                    if (param.d.defaultValue) {
                         sawDefaultParam = true;
                     }
                     else if (sawDefaultParam && !sawKeywordOnlySeparator && !sawArgs) {
@@ -1569,8 +1570,8 @@ class Parser {
                 }
             }
             paramList.push(param);
-            if (param.category === 1 /* ParameterCategory.ArgsList */) {
-                if (!param.name) {
+            if (param.d.category === 1 /* ParameterCategory.ArgsList */) {
+                if (!param.d.name) {
                     if (sawKeywordOnlySeparator) {
                         this._addSyntaxError(localize_1.LocMessage.duplicateKeywordOnly(), param);
                     }
@@ -1586,7 +1587,7 @@ class Parser {
                     sawArgs = true;
                 }
             }
-            if (param.category === 2 /* ParameterCategory.KwargsDict */) {
+            if (param.d.category === 2 /* ParameterCategory.KwargsDict */) {
                 if (sawKwArgs) {
                     this._addSyntaxError(localize_1.LocMessage.duplicateKwargsParam(), param);
                 }
@@ -1600,13 +1601,13 @@ class Parser {
                 this._addSyntaxError(localize_1.LocMessage.paramAfterKwargsParam(), param);
             }
             const foundComma = this._consumeTokenIfType(12 /* TokenType.Comma */);
-            if (allowAnnotations && !param.typeAnnotation) {
+            if (allowAnnotations && !param.d.annotation) {
                 // Look for a type annotation comment at the end of the line.
                 const typeAnnotationComment = this._parseVariableTypeAnnotationComment();
                 if (typeAnnotationComment) {
-                    param.typeAnnotationComment = typeAnnotationComment;
-                    param.typeAnnotationComment.parent = param;
-                    (0, parseNodes_1.extendRange)(param, param.typeAnnotationComment);
+                    param.d.annotationComment = typeAnnotationComment;
+                    param.d.annotationComment.parent = param;
+                    (0, parseNodes_1.extendRange)(param, param.d.annotationComment);
                 }
             }
             if (!foundComma) {
@@ -1615,7 +1616,7 @@ class Parser {
         }
         if (paramList.length > 0) {
             const lastParam = paramList[paramList.length - 1];
-            if (lastParam.category === 1 /* ParameterCategory.ArgsList */ && !lastParam.name) {
+            if (lastParam.d.category === 1 /* ParameterCategory.ArgsList */ && !lastParam.d.name) {
                 this._addSyntaxError(localize_1.LocMessage.expectedNamedParameter(), lastParam);
             }
         }
@@ -1668,21 +1669,21 @@ class Parser {
         }
         const paramNode = parseNodes_1.ParameterNode.create(firstToken, paramType);
         if (paramName) {
-            paramNode.name = parseNodes_1.NameNode.create(paramName);
-            paramNode.name.parent = paramNode;
+            paramNode.d.name = parseNodes_1.NameNode.create(paramName);
+            paramNode.d.name.parent = paramNode;
             (0, parseNodes_1.extendRange)(paramNode, paramName);
         }
         if (allowAnnotations && this._consumeTokenIfType(10 /* TokenType.Colon */)) {
-            paramNode.typeAnnotation = this._parseTypeAnnotation(paramType === 1 /* ParameterCategory.ArgsList */);
-            paramNode.typeAnnotation.parent = paramNode;
-            (0, parseNodes_1.extendRange)(paramNode, paramNode.typeAnnotation);
+            paramNode.d.annotation = this._parseTypeAnnotation(paramType === 1 /* ParameterCategory.ArgsList */);
+            paramNode.d.annotation.parent = paramNode;
+            (0, parseNodes_1.extendRange)(paramNode, paramNode.d.annotation);
         }
         if (this._consumeTokenIfOperator(2 /* OperatorType.Assign */)) {
-            paramNode.defaultValue = this._parseTestExpression(/* allowAssignmentExpression */ false);
-            paramNode.defaultValue.parent = paramNode;
-            (0, parseNodes_1.extendRange)(paramNode, paramNode.defaultValue);
+            paramNode.d.defaultValue = this._parseTestExpression(/* allowAssignmentExpression */ false);
+            paramNode.d.defaultValue.parent = paramNode;
+            (0, parseNodes_1.extendRange)(paramNode, paramNode.d.defaultValue);
             if (starCount > 0) {
-                this._addSyntaxError(localize_1.LocMessage.defaultValueNotAllowed(), paramNode.defaultValue);
+                this._addSyntaxError(localize_1.LocMessage.defaultValueNotAllowed(), paramNode.d.defaultValue);
             }
         }
         return paramNode;
@@ -1714,7 +1715,7 @@ class Parser {
                 }
                 if (this._peekToken().type === 14 /* TokenType.CloseParenthesis */ &&
                     this._peekToken(1).type === 10 /* TokenType.Colon */) {
-                    isParenthesizedWithItemList = withItemList.length !== 1 || withItemList[0].target !== undefined;
+                    isParenthesizedWithItemList = withItemList.length !== 1 || withItemList[0].d.target !== undefined;
                 }
                 this._tokenIndex = openParenTokenIndex;
                 withItemList = [];
@@ -1749,14 +1750,14 @@ class Parser {
         });
         const withNode = parseNodes_1.WithNode.create(withToken, withSuite);
         if (asyncToken) {
-            withNode.isAsync = true;
-            withNode.asyncToken = asyncToken;
+            withNode.d.isAsync = true;
+            withNode.d.asyncToken = asyncToken;
             (0, parseNodes_1.extendRange)(withNode, asyncToken);
         }
         if (typeComment) {
-            withNode.typeComment = typeComment;
+            withNode.d.typeComment = typeComment;
         }
-        withNode.withItems = withItemList;
+        withNode.d.withItems = withItemList;
         withItemList.forEach((withItem) => {
             withItem.parent = withNode;
         });
@@ -1767,9 +1768,9 @@ class Parser {
         const expr = this._parseTestExpression(/* allowAssignmentExpression */ true);
         const itemNode = parseNodes_1.WithItemNode.create(expr);
         if (this._consumeTokenIfKeyword(1 /* KeywordType.As */)) {
-            itemNode.target = this._parseExpression(/* allowUnpack */ false);
-            itemNode.target.parent = itemNode;
-            (0, parseNodes_1.extendRange)(itemNode, itemNode.target);
+            itemNode.d.target = this._parseExpression(/* allowUnpack */ false);
+            itemNode.d.target.parent = itemNode;
+            (0, parseNodes_1.extendRange)(itemNode, itemNode.d.target);
         }
         return itemNode;
     }
@@ -1821,7 +1822,7 @@ class Parser {
                 isSupportedExpressionForm = true;
             }
             else if (expression.nodeType === 9 /* ParseNodeType.Call */ &&
-                this._isNameOrMemberAccessExpression(expression.leftExpression)) {
+                this._isNameOrMemberAccessExpression(expression.d.leftExpr)) {
                 isSupportedExpressionForm = true;
             }
             if (!isSupportedExpressionForm) {
@@ -1840,7 +1841,7 @@ class Parser {
             return true;
         }
         else if (expression.nodeType === 35 /* ParseNodeType.MemberAccess */) {
-            return this._isNameOrMemberAccessExpression(expression.leftExpression);
+            return this._isNameOrMemberAccessExpression(expression.d.leftExpr);
         }
         return false;
     }
@@ -1870,12 +1871,12 @@ class Parser {
         }
         const suite = this._parseSuite(/* isFunction */ false, this._parseOptions.skipFunctionAndClassBody);
         const classNode = parseNodes_1.ClassNode.create(classToken, parseNodes_1.NameNode.create(nameToken), suite, typeParameters);
-        classNode.arguments = argList;
+        classNode.d.arguments = argList;
         argList.forEach((arg) => {
             arg.parent = classNode;
         });
         if (decorators) {
-            classNode.decorators = decorators;
+            classNode.d.decorators = decorators;
             if (decorators.length > 0) {
                 decorators.forEach((decorator) => {
                     decorator.parent = classNode;
@@ -1917,8 +1918,8 @@ class Parser {
             /* allowAssignmentExpression */ true, 
             /* allowMultipleUnpack */ true, 2 /* ErrorExpressionCategory.MissingExpression */, () => localize_1.LocMessage.expectedReturnExpr());
             this._reportConditionalErrorForStarTupleElement(returnExpr);
-            returnNode.returnExpression = returnExpr;
-            returnNode.returnExpression.parent = returnNode;
+            returnNode.d.expr = returnExpr;
+            returnNode.d.expr.parent = returnNode;
             (0, parseNodes_1.extendRange)(returnNode, returnExpr);
         }
         return returnNode;
@@ -1933,12 +1934,14 @@ class Parser {
         const importFromNode = parseNodes_1.ImportFromNode.create(fromToken, modName);
         // Handle imports from __future__ specially because they can
         // change the way we interpret the rest of the file.
-        const isFutureImport = modName.leadingDots === 0 && modName.nameParts.length === 1 && modName.nameParts[0].value === '__future__';
+        const isFutureImport = modName.d.leadingDots === 0 &&
+            modName.d.nameParts.length === 1 &&
+            modName.d.nameParts[0].d.value === '__future__';
         const possibleInputToken = this._peekToken();
         if (!this._consumeTokenIfKeyword(21 /* KeywordType.Import */)) {
             this._addSyntaxError(localize_1.LocMessage.expectedImport(), this._peekToken());
-            if (!modName.hasTrailingDot) {
-                importFromNode.missingImportKeyword = true;
+            if (!modName.d.hasTrailingDot) {
+                importFromNode.d.missingImport = true;
             }
         }
         else {
@@ -1947,8 +1950,8 @@ class Parser {
             const possibleStarToken = this._peekToken();
             if (this._consumeTokenIfOperator(26 /* OperatorType.Multiply */)) {
                 (0, parseNodes_1.extendRange)(importFromNode, possibleStarToken);
-                importFromNode.isWildcardImport = true;
-                importFromNode.wildcardToken = possibleStarToken;
+                importFromNode.d.isWildcardImport = true;
+                importFromNode.d.wildcardToken = possibleStarToken;
                 this._containsWildcardImport = true;
             }
             else {
@@ -1968,12 +1971,12 @@ class Parser {
                             this._addSyntaxError(localize_1.LocMessage.expectedImportAlias(), this._peekToken());
                         }
                         else {
-                            importFromAsNode.alias = parseNodes_1.NameNode.create(aliasName);
-                            importFromAsNode.alias.parent = importFromAsNode;
+                            importFromAsNode.d.alias = parseNodes_1.NameNode.create(aliasName);
+                            importFromAsNode.d.alias.parent = importFromAsNode;
                             (0, parseNodes_1.extendRange)(importFromAsNode, aliasName);
                         }
                     }
-                    importFromNode.imports.push(importFromAsNode);
+                    importFromNode.d.imports.push(importFromAsNode);
                     importFromAsNode.parent = importFromNode;
                     (0, parseNodes_1.extendRange)(importFromNode, importFromAsNode);
                     if (isFutureImport) {
@@ -1986,11 +1989,11 @@ class Parser {
                     }
                     trailingCommaToken = nextToken;
                 }
-                if (importFromNode.imports.length === 0) {
+                if (importFromNode.d.imports.length === 0) {
                     this._addSyntaxError(localize_1.LocMessage.expectedImportSymbols(), this._peekToken());
                 }
                 if (inParen) {
-                    importFromNode.usesParens = true;
+                    importFromNode.d.usesParens = true;
                     const nextToken = this._peekToken();
                     if (!this._consumeTokenIfType(14 /* TokenType.CloseParenthesis */)) {
                         this._addSyntaxError(localize_1.LocMessage.expectedCloseParen(), openParenToken);
@@ -2005,30 +2008,30 @@ class Parser {
             }
         }
         this._importedModules.push({
-            nameNode: importFromNode.module,
-            leadingDots: importFromNode.module.leadingDots,
-            nameParts: importFromNode.module.nameParts.map((p) => p.value),
-            importedSymbols: new Set(importFromNode.imports.map((imp) => imp.name.value)),
+            nameNode: importFromNode.d.module,
+            leadingDots: importFromNode.d.module.d.leadingDots,
+            nameParts: importFromNode.d.module.d.nameParts.map((p) => p.d.value),
+            importedSymbols: new Set(importFromNode.d.imports.map((imp) => imp.d.name.d.value)),
         });
         let isTypingImport = false;
-        if (importFromNode.module.nameParts.length === 1) {
-            const firstNamePartValue = importFromNode.module.nameParts[0].value;
+        if (importFromNode.d.module.d.nameParts.length === 1) {
+            const firstNamePartValue = importFromNode.d.module.d.nameParts[0].d.value;
             if (firstNamePartValue === 'typing' || firstNamePartValue === 'typing_extensions') {
                 isTypingImport = true;
             }
         }
         if (isTypingImport) {
             const typingSymbolsOfInterest = ['Literal', 'TypeAlias', 'Annotated'];
-            if (importFromNode.isWildcardImport) {
+            if (importFromNode.d.isWildcardImport) {
                 typingSymbolsOfInterest.forEach((s) => {
                     this._typingSymbolAliases.set(s, s);
                 });
             }
             else {
-                importFromNode.imports.forEach((imp) => {
+                importFromNode.d.imports.forEach((imp) => {
                     var _a;
-                    if (typingSymbolsOfInterest.some((s) => s === imp.name.value)) {
-                        this._typingSymbolAliases.set(((_a = imp.alias) === null || _a === void 0 ? void 0 : _a.value) || imp.name.value, imp.name.value);
+                    if (typingSymbolsOfInterest.some((s) => s === imp.d.name.d.value)) {
+                        this._typingSymbolAliases.set(((_a = imp.d.alias) === null || _a === void 0 ? void 0 : _a.d.value) || imp.d.name.d.value, imp.d.name.d.value);
                     }
                 });
             }
@@ -2048,26 +2051,26 @@ class Parser {
             if (this._consumeTokenIfKeyword(1 /* KeywordType.As */)) {
                 const aliasToken = this._getTokenIfIdentifier();
                 if (aliasToken) {
-                    importAsNode.alias = parseNodes_1.NameNode.create(aliasToken);
-                    importAsNode.alias.parent = importAsNode;
-                    (0, parseNodes_1.extendRange)(importAsNode, importAsNode.alias);
+                    importAsNode.d.alias = parseNodes_1.NameNode.create(aliasToken);
+                    importAsNode.d.alias.parent = importAsNode;
+                    (0, parseNodes_1.extendRange)(importAsNode, importAsNode.d.alias);
                 }
                 else {
                     this._addSyntaxError(localize_1.LocMessage.expectedImportAlias(), this._peekToken());
                 }
             }
-            if (importAsNode.module.leadingDots > 0) {
-                this._addSyntaxError(localize_1.LocMessage.relativeImportNotAllowed(), importAsNode.module);
+            if (importAsNode.d.module.d.leadingDots > 0) {
+                this._addSyntaxError(localize_1.LocMessage.relativeImportNotAllowed(), importAsNode.d.module);
             }
-            importNode.list.push(importAsNode);
+            importNode.d.list.push(importAsNode);
             importAsNode.parent = importNode;
-            const nameParts = importAsNode.module.nameParts.map((p) => p.value);
-            if (importAsNode.alias ||
-                importAsNode.module.leadingDots > 0 ||
-                importAsNode.module.nameParts.length === 0) {
+            const nameParts = importAsNode.d.module.d.nameParts.map((p) => p.d.value);
+            if (importAsNode.d.alias ||
+                importAsNode.d.module.d.leadingDots > 0 ||
+                importAsNode.d.module.d.nameParts.length === 0) {
                 this._importedModules.push({
-                    nameNode: importAsNode.module,
-                    leadingDots: importAsNode.module.leadingDots,
+                    nameNode: importAsNode.d.module,
+                    leadingDots: importAsNode.d.module.d.leadingDots,
                     nameParts,
                     importedSymbols: undefined,
                 });
@@ -2075,27 +2078,27 @@ class Parser {
             else {
                 // Implicitly import all modules in the multi-part name if we
                 // are not assigning the final module to an alias.
-                importAsNode.module.nameParts.forEach((_, index) => {
+                importAsNode.d.module.d.nameParts.forEach((_, index) => {
                     this._importedModules.push({
-                        nameNode: importAsNode.module,
-                        leadingDots: importAsNode.module.leadingDots,
+                        nameNode: importAsNode.d.module,
+                        leadingDots: importAsNode.d.module.d.leadingDots,
                         nameParts: nameParts.slice(0, index + 1),
                         importedSymbols: undefined,
                     });
                 });
             }
-            if (modName.nameParts.length === 1) {
-                const firstNamePartValue = modName.nameParts[0].value;
+            if (modName.d.nameParts.length === 1) {
+                const firstNamePartValue = modName.d.nameParts[0].d.value;
                 if (firstNamePartValue === 'typing' || firstNamePartValue === 'typing_extensions') {
-                    this._typingImportAliases.push(((_a = importAsNode.alias) === null || _a === void 0 ? void 0 : _a.value) || firstNamePartValue);
+                    this._typingImportAliases.push(((_a = importAsNode.d.alias) === null || _a === void 0 ? void 0 : _a.d.value) || firstNamePartValue);
                 }
             }
             if (!this._consumeTokenIfType(12 /* TokenType.Comma */)) {
                 break;
             }
         }
-        if (importNode.list.length > 0) {
-            (0, parseNodes_1.extendRange)(importNode, importNode.list[importNode.list.length - 1]);
+        if (importNode.d.list.length > 0) {
+            (0, parseNodes_1.extendRange)(importNode, importNode.d.list[importNode.d.list.length - 1]);
         }
         return importNode;
     }
@@ -2108,10 +2111,10 @@ class Parser {
             const token = (_a = this._getTokenIfType(19 /* TokenType.Ellipsis */)) !== null && _a !== void 0 ? _a : this._getTokenIfType(20 /* TokenType.Dot */);
             if (token) {
                 if (token.type === 19 /* TokenType.Ellipsis */) {
-                    moduleNameNode.leadingDots += 3;
+                    moduleNameNode.d.leadingDots += 3;
                 }
                 else {
-                    moduleNameNode.leadingDots++;
+                    moduleNameNode.d.leadingDots++;
                 }
                 (0, parseNodes_1.extendRange)(moduleNameNode, token);
             }
@@ -2122,14 +2125,14 @@ class Parser {
         while (true) {
             const identifier = this._getTokenIfIdentifier();
             if (!identifier) {
-                if (!allowJustDots || moduleNameNode.leadingDots === 0 || moduleNameNode.nameParts.length > 0) {
+                if (!allowJustDots || moduleNameNode.d.leadingDots === 0 || moduleNameNode.d.nameParts.length > 0) {
                     this._addSyntaxError(localize_1.LocMessage.expectedModuleName(), this._peekToken());
-                    moduleNameNode.hasTrailingDot = true;
+                    moduleNameNode.d.hasTrailingDot = true;
                 }
                 break;
             }
             const namePart = parseNodes_1.NameNode.create(identifier);
-            moduleNameNode.nameParts.push(namePart);
+            moduleNameNode.d.nameParts.push(namePart);
             namePart.parent = moduleNameNode;
             (0, parseNodes_1.extendRange)(moduleNameNode, namePart);
             const nextToken = this._peekToken();
@@ -2144,24 +2147,24 @@ class Parser {
     _parseGlobalStatement() {
         const globalToken = this._getKeywordToken(19 /* KeywordType.Global */);
         const globalNode = parseNodes_1.GlobalNode.create(globalToken);
-        globalNode.nameList = this._parseNameList();
-        if (globalNode.nameList.length > 0) {
-            globalNode.nameList.forEach((name) => {
+        globalNode.d.targets = this._parseNameList();
+        if (globalNode.d.targets.length > 0) {
+            globalNode.d.targets.forEach((name) => {
                 name.parent = globalNode;
             });
-            (0, parseNodes_1.extendRange)(globalNode, globalNode.nameList[globalNode.nameList.length - 1]);
+            (0, parseNodes_1.extendRange)(globalNode, globalNode.d.targets[globalNode.d.targets.length - 1]);
         }
         return globalNode;
     }
     _parseNonlocalStatement() {
         const nonlocalToken = this._getKeywordToken(27 /* KeywordType.Nonlocal */);
         const nonlocalNode = parseNodes_1.NonlocalNode.create(nonlocalToken);
-        nonlocalNode.nameList = this._parseNameList();
-        if (nonlocalNode.nameList.length > 0) {
-            nonlocalNode.nameList.forEach((name) => {
+        nonlocalNode.d.targets = this._parseNameList();
+        if (nonlocalNode.d.targets.length > 0) {
+            nonlocalNode.d.targets.forEach((name) => {
                 name.parent = nonlocalNode;
             });
-            (0, parseNodes_1.extendRange)(nonlocalNode, nonlocalNode.nameList[nonlocalNode.nameList.length - 1]);
+            (0, parseNodes_1.extendRange)(nonlocalNode, nonlocalNode.d.targets[nonlocalNode.d.targets.length - 1]);
         }
         return nonlocalNode;
     }
@@ -2186,24 +2189,25 @@ class Parser {
         const raiseToken = this._getKeywordToken(31 /* KeywordType.Raise */);
         const raiseNode = parseNodes_1.RaiseNode.create(raiseToken);
         if (!this._isNextTokenNeverExpression()) {
-            raiseNode.typeExpression = this._parseTestExpression(/* allowAssignmentExpression */ true);
-            raiseNode.typeExpression.parent = raiseNode;
-            (0, parseNodes_1.extendRange)(raiseNode, raiseNode.typeExpression);
+            raiseNode.d.typeExpression = this._parseTestExpression(/* allowAssignmentExpression */ true);
+            raiseNode.d.typeExpression.parent = raiseNode;
+            (0, parseNodes_1.extendRange)(raiseNode, raiseNode.d.typeExpression);
             if (this._consumeTokenIfKeyword(18 /* KeywordType.From */)) {
-                raiseNode.valueExpression = this._parseTestExpression(/* allowAssignmentExpression */ true);
-                raiseNode.valueExpression.parent = raiseNode;
-                (0, parseNodes_1.extendRange)(raiseNode, raiseNode.valueExpression);
+                raiseNode.d.valueExpression = this._parseTestExpression(/* allowAssignmentExpression */ true);
+                raiseNode.d.valueExpression.parent = raiseNode;
+                (0, parseNodes_1.extendRange)(raiseNode, raiseNode.d.valueExpression);
             }
             else {
                 if (this._consumeTokenIfType(12 /* TokenType.Comma */)) {
                     // Handle the Python 2.x variant
-                    raiseNode.valueExpression = this._parseTestExpression(/* allowAssignmentExpression */ true);
-                    raiseNode.valueExpression.parent = raiseNode;
-                    (0, parseNodes_1.extendRange)(raiseNode, raiseNode.valueExpression);
+                    raiseNode.d.valueExpression = this._parseTestExpression(/* allowAssignmentExpression */ true);
+                    raiseNode.d.valueExpression.parent = raiseNode;
+                    (0, parseNodes_1.extendRange)(raiseNode, raiseNode.d.valueExpression);
                     if (this._consumeTokenIfType(12 /* TokenType.Comma */)) {
-                        raiseNode.tracebackExpression = this._parseTestExpression(/* allowAssignmentExpression */ true);
-                        raiseNode.tracebackExpression.parent = raiseNode;
-                        (0, parseNodes_1.extendRange)(raiseNode, raiseNode.tracebackExpression);
+                        raiseNode.d.tracebackExpression = this._parseTestExpression(
+                        /* allowAssignmentExpression */ true);
+                        raiseNode.d.tracebackExpression.parent = raiseNode;
+                        (0, parseNodes_1.extendRange)(raiseNode, raiseNode.d.tracebackExpression);
                     }
                 }
             }
@@ -2217,8 +2221,8 @@ class Parser {
         const assertNode = parseNodes_1.AssertNode.create(assertToken, expr);
         if (this._consumeTokenIfType(12 /* TokenType.Comma */)) {
             const exceptionExpr = this._parseTestExpression(/* allowAssignmentExpression */ false);
-            assertNode.exceptionExpression = exceptionExpr;
-            assertNode.exceptionExpression.parent = assertNode;
+            assertNode.d.exceptionExpr = exceptionExpr;
+            assertNode.d.exceptionExpr.parent = assertNode;
             (0, parseNodes_1.extendRange)(assertNode, exceptionExpr);
         }
         return assertNode;
@@ -2231,12 +2235,12 @@ class Parser {
             this._addSyntaxError(localize_1.LocMessage.expectedDelExpr(), this._peekToken());
         }
         const delNode = parseNodes_1.DelNode.create(delToken);
-        delNode.expressions = exprListResult.list;
-        if (delNode.expressions.length > 0) {
-            delNode.expressions.forEach((expr) => {
+        delNode.d.targets = exprListResult.list;
+        if (delNode.d.targets.length > 0) {
+            delNode.d.targets.forEach((expr) => {
                 expr.parent = delNode;
             });
-            (0, parseNodes_1.extendRange)(delNode, delNode.expressions[delNode.expressions.length - 1]);
+            (0, parseNodes_1.extendRange)(delNode, delNode.d.targets[delNode.d.targets.length - 1]);
         }
         return delNode;
     }
@@ -2281,7 +2285,7 @@ class Parser {
                 break;
             }
             const smallStatement = this._parseSmallStatement();
-            statement.statements.push(smallStatement);
+            statement.d.statements.push(smallStatement);
             smallStatement.parent = statement;
             (0, parseNodes_1.extendRange)(statement, smallStatement);
             if (smallStatement.nodeType === 0 /* ParseNodeType.Error */) {
@@ -2370,7 +2374,7 @@ class Parser {
         // the opening parenthesis as the opening token.
         const tupleStartRange = exprListResult.list.length > 0 ? exprListResult.list[0] : this._peekToken(-1);
         const tupleNode = parseNodes_1.TupleNode.create(tupleStartRange, enclosedInParens);
-        tupleNode.expressions = exprListResult.list;
+        tupleNode.d.items = exprListResult.list;
         if (exprListResult.list.length > 0) {
             exprListResult.list.forEach((expr) => {
                 expr.parent = tupleNode;
@@ -2716,15 +2720,14 @@ class Parser {
     // to refer to the typing types.
     _isTypingAnnotation(typeAnnotation, name) {
         if (typeAnnotation.nodeType === 38 /* ParseNodeType.Name */) {
-            const alias = this._typingSymbolAliases.get(typeAnnotation.value);
+            const alias = this._typingSymbolAliases.get(typeAnnotation.d.value);
             if (alias === name) {
                 return true;
             }
         }
         else if (typeAnnotation.nodeType === 35 /* ParseNodeType.MemberAccess */) {
-            if (typeAnnotation.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
-                typeAnnotation.memberName.value === name) {
-                const baseName = typeAnnotation.leftExpression.value;
+            if (typeAnnotation.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ && typeAnnotation.d.member.d.value === name) {
+                const baseName = typeAnnotation.d.leftExpr.d.value;
                 return this._typingImportAliases.some((alias) => alias === baseName);
             }
         }
@@ -2733,6 +2736,7 @@ class Parser {
     // atom_expr: ['await'] atom trailer*
     // trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME
     _parseAtomExpression() {
+        var _a, _b, _c;
         let awaitToken;
         if (this._peekKeywordType() === 4 /* KeywordType.Await */) {
             awaitToken = this._getKeywordToken(4 /* KeywordType.Await */);
@@ -2757,9 +2761,9 @@ class Parser {
                 const callNode = parseNodes_1.CallNode.create(atomExpression, argListResult.args, argListResult.trailingComma);
                 if (argListResult.args.length > 1 || argListResult.trailingComma) {
                     argListResult.args.forEach((arg) => {
-                        if (arg.valueExpression.nodeType === 11 /* ParseNodeType.Comprehension */) {
-                            if (!arg.valueExpression.isParenthesized) {
-                                this._addSyntaxError(localize_1.LocMessage.generatorNotParenthesized(), arg.valueExpression);
+                        if (arg.d.valueExpr.nodeType === 11 /* ParseNodeType.Comprehension */) {
+                            if (!arg.d.valueExpr.d.hasParens) {
+                                this._addSyntaxError(localize_1.LocMessage.generatorNotParenthesized(), arg.d.valueExpr);
                             }
                         }
                     });
@@ -2780,11 +2784,15 @@ class Parser {
                     isArgListTerminated = true;
                 }
                 this._isParsingTypeAnnotation = wasParsingTypeAnnotation;
-                atomExpression = callNode;
-                if (atomExpression.maxChildDepth !== undefined && atomExpression.maxChildDepth >= maxChildNodeDepth) {
-                    atomExpression = parseNodes_1.ErrorNode.create(atomExpression, 14 /* ErrorExpressionCategory.MaxDepthExceeded */);
+                const maxDepth = (_a = this._maxChildDepthMap.get(atomExpression.id)) !== null && _a !== void 0 ? _a : 0;
+                if (maxDepth >= maxChildNodeDepth) {
+                    atomExpression = parseNodes_1.ErrorNode.create(callNode, 15 /* ErrorExpressionCategory.MaxDepthExceeded */);
                     this._addSyntaxError(localize_1.LocMessage.maxParseDepthExceeded(), atomExpression);
                 }
+                else {
+                    atomExpression = callNode;
+                    this._maxChildDepthMap.set(callNode.id, maxDepth + 1);
+                }
                 // If the argument list wasn't terminated, break out of the loop
                 if (!isArgListTerminated) {
                     break;
@@ -2813,11 +2821,15 @@ class Parser {
                     // case because it creates problems for the completion provider.
                     this._handleExpressionParseError(6 /* ErrorExpressionCategory.MissingIndexCloseBracket */, localize_1.LocMessage.expectedCloseBracket(), startOfTrailerToken, indexNode);
                 }
-                atomExpression = indexNode;
-                if (atomExpression.maxChildDepth !== undefined && atomExpression.maxChildDepth >= maxChildNodeDepth) {
-                    atomExpression = parseNodes_1.ErrorNode.create(atomExpression, 14 /* ErrorExpressionCategory.MaxDepthExceeded */);
+                const maxDepth = (_b = this._maxChildDepthMap.get(atomExpression.id)) !== null && _b !== void 0 ? _b : 0;
+                if (maxDepth >= maxChildNodeDepth) {
+                    atomExpression = parseNodes_1.ErrorNode.create(indexNode, 15 /* ErrorExpressionCategory.MaxDepthExceeded */);
                     this._addSyntaxError(localize_1.LocMessage.maxParseDepthExceeded(), atomExpression);
                 }
+                else {
+                    atomExpression = indexNode;
+                    this._maxChildDepthMap.set(indexNode.id, maxDepth + 1);
+                }
             }
             else if (this._consumeTokenIfType(20 /* TokenType.Dot */)) {
                 // Is it a member access?
@@ -2825,11 +2837,16 @@ class Parser {
                 if (!memberName) {
                     return this._handleExpressionParseError(7 /* ErrorExpressionCategory.MissingMemberAccessName */, localize_1.LocMessage.expectedMemberName(), startOfTrailerToken, atomExpression, [8 /* TokenType.Keyword */]);
                 }
-                atomExpression = parseNodes_1.MemberAccessNode.create(atomExpression, parseNodes_1.NameNode.create(memberName));
-                if (atomExpression.maxChildDepth !== undefined && atomExpression.maxChildDepth >= maxChildNodeDepth) {
-                    atomExpression = parseNodes_1.ErrorNode.create(atomExpression, 14 /* ErrorExpressionCategory.MaxDepthExceeded */);
+                const memberAccessNode = parseNodes_1.MemberAccessNode.create(atomExpression, parseNodes_1.NameNode.create(memberName));
+                const maxDepth = (_c = this._maxChildDepthMap.get(atomExpression.id)) !== null && _c !== void 0 ? _c : 0;
+                if (maxDepth >= maxChildNodeDepth) {
+                    atomExpression = parseNodes_1.ErrorNode.create(memberAccessNode, 15 /* ErrorExpressionCategory.MaxDepthExceeded */);
                     this._addSyntaxError(localize_1.LocMessage.maxParseDepthExceeded(), atomExpression);
                 }
+                else {
+                    atomExpression = memberAccessNode;
+                    this._maxChildDepthMap.set(memberAccessNode.id, maxDepth + 1);
+                }
             }
             else {
                 break;
@@ -2866,7 +2883,7 @@ class Parser {
                     const nameExpr = valueExpr;
                     valueExpr = this._parsePossibleSlice();
                     if (nameExpr.nodeType === 38 /* ParseNodeType.Name */) {
-                        nameIdentifier = nameExpr.token;
+                        nameIdentifier = nameExpr.d.token;
                     }
                     else {
                         this._addSyntaxError(localize_1.LocMessage.expectedParamName(), nameExpr);
@@ -2884,18 +2901,18 @@ class Parser {
             }
             const argNode = parseNodes_1.ArgumentNode.create(firstToken, valueExpr, argType);
             if (nameIdentifier) {
-                argNode.name = parseNodes_1.NameNode.create(nameIdentifier);
-                argNode.name.parent = argNode;
+                argNode.d.name = parseNodes_1.NameNode.create(nameIdentifier);
+                argNode.d.name.parent = argNode;
             }
-            if (argNode.name) {
+            if (argNode.d.name) {
                 sawKeywordArg = true;
             }
-            else if (sawKeywordArg && argNode.argumentCategory === 0 /* ArgumentCategory.Simple */) {
+            else if (sawKeywordArg && argNode.d.argCategory === 0 /* ArgumentCategory.Simple */) {
                 this._addSyntaxError(localize_1.LocMessage.positionArgAfterNamedArg(), argNode);
             }
             argList.push(argNode);
-            if (argNode.name) {
-                this._addSyntaxError(localize_1.LocMessage.keywordSubscriptIllegal(), argNode.name);
+            if (argNode.d.name) {
+                this._addSyntaxError(localize_1.LocMessage.keywordSubscriptIllegal(), argNode.d.name);
             }
             if (argType !== 0 /* ArgumentCategory.Simple */) {
                 const unpackListAllowed = this._parseOptions.isStubFile ||
@@ -2957,17 +2974,17 @@ class Parser {
             return parseNodes_1.ErrorNode.create(this._peekToken(), 3 /* ErrorExpressionCategory.MissingIndexOrSlice */);
         }
         const sliceNode = parseNodes_1.SliceNode.create(firstToken);
-        sliceNode.startValue = sliceExpressions[0];
-        if (sliceNode.startValue) {
-            sliceNode.startValue.parent = sliceNode;
+        sliceNode.d.startValue = sliceExpressions[0];
+        if (sliceNode.d.startValue) {
+            sliceNode.d.startValue.parent = sliceNode;
         }
-        sliceNode.endValue = sliceExpressions[1];
-        if (sliceNode.endValue) {
-            sliceNode.endValue.parent = sliceNode;
+        sliceNode.d.endValue = sliceExpressions[1];
+        if (sliceNode.d.endValue) {
+            sliceNode.d.endValue.parent = sliceNode;
         }
-        sliceNode.stepValue = sliceExpressions[2];
-        if (sliceNode.stepValue) {
-            sliceNode.stepValue.parent = sliceNode;
+        sliceNode.d.stepValue = sliceExpressions[2];
+        if (sliceNode.d.stepValue) {
+            sliceNode.d.stepValue.parent = sliceNode;
         }
         const extension = sliceExpressions[2] || sliceExpressions[1] || sliceExpressions[0];
         if (extension) {
@@ -2989,10 +3006,10 @@ class Parser {
             }
             trailingComma = false;
             const arg = this._parseArgument();
-            if (arg.name) {
+            if (arg.d.name) {
                 sawKeywordArg = true;
             }
-            else if (sawKeywordArg && arg.argumentCategory === 0 /* ArgumentCategory.Simple */) {
+            else if (sawKeywordArg && arg.d.argCategory === 0 /* ArgumentCategory.Simple */) {
                 this._addSyntaxError(localize_1.LocMessage.positionArgAfterNamedArg(), arg);
             }
             argList.push(arg);
@@ -3004,7 +3021,8 @@ class Parser {
         return { args: argList, trailingComma };
     }
     // argument: ( test [comp_for] |
-    //             test '=' test |
+    //             name '=' test |
+    //             name '=' |
     //             '**' test |
     //             '*' test )
     _parseArgument() {
@@ -3017,16 +3035,34 @@ class Parser {
             argType = 2 /* ArgumentCategory.UnpackedDictionary */;
         }
         let valueExpr = this._parseTestExpression(/* allowAssignmentExpression */ true);
-        let nameIdentifier;
+        let nameNode;
+        let isNameSameAsValue = false;
+        let assignmentToken;
         if (argType === 0 /* ArgumentCategory.Simple */) {
+            const nextToken = this._peekToken();
             if (this._consumeTokenIfOperator(2 /* OperatorType.Assign */)) {
+                assignmentToken = nextToken;
                 const nameExpr = valueExpr;
-                valueExpr = this._parseTestExpression(/* allowAssignmentExpression */ false);
-                if (nameExpr.nodeType === 38 /* ParseNodeType.Name */) {
-                    nameIdentifier = nameExpr.token;
+                if (nameExpr.nodeType === 38 /* ParseNodeType.Name */ &&
+                    (this._peekTokenType() === 12 /* TokenType.Comma */ || this._peekTokenType() === 14 /* TokenType.CloseParenthesis */)) {
+                    nameNode = parseNodes_1.NameNode.create(nameExpr.d.token);
+                    if (this._getLanguageVersion().isLessThan(pythonVersion_1.pythonVersion3_14)) {
+                        this._addSyntaxError(localize_1.LocMessage.keywordArgShortcutIllegal(), assignmentToken);
+                        valueExpr = parseNodes_1.ErrorNode.create(assignmentToken, 14 /* ErrorExpressionCategory.MissingKeywordArgValue */);
+                    }
+                    else {
+                        valueExpr = parseNodes_1.NameNode.create(nameExpr.d.token);
+                        isNameSameAsValue = true;
+                    }
                 }
                 else {
-                    this._addSyntaxError(localize_1.LocMessage.expectedParamName(), nameExpr);
+                    valueExpr = this._parseTestExpression(/* allowAssignmentExpression */ false);
+                    if (nameExpr.nodeType === 38 /* ParseNodeType.Name */) {
+                        nameNode = parseNodes_1.NameNode.create(nameExpr.d.token);
+                    }
+                    else {
+                        this._addSyntaxError(localize_1.LocMessage.expectedParamName(), nameExpr);
+                    }
                 }
             }
             else {
@@ -3037,9 +3073,13 @@ class Parser {
             }
         }
         const argNode = parseNodes_1.ArgumentNode.create(firstToken, valueExpr, argType);
-        if (nameIdentifier) {
-            argNode.name = parseNodes_1.NameNode.create(nameIdentifier);
-            argNode.name.parent = argNode;
+        if (nameNode) {
+            argNode.d.name = nameNode;
+            argNode.d.isNameSameAsValue = isNameSameAsValue;
+            argNode.d.name.parent = argNode;
+            if (assignmentToken) {
+                (0, parseNodes_1.extendRange)(argNode, assignmentToken);
+            }
         }
         return argNode;
     }
@@ -3080,12 +3120,12 @@ class Parser {
                 // to use comparison chaining, which isn't appropriate when the
                 // expression is parenthesized. Unary and await expressions
                 // are also marked to be able to display them unambiguously.
-                possibleTupleNode.parenthesized = true;
+                possibleTupleNode.d.hasParens = true;
             }
             if (possibleTupleNode.nodeType === 48 /* ParseNodeType.StringList */ ||
                 possibleTupleNode.nodeType === 11 /* ParseNodeType.Comprehension */ ||
                 possibleTupleNode.nodeType === 4 /* ParseNodeType.AssignmentExpression */) {
-                possibleTupleNode.isParenthesized = true;
+                possibleTupleNode.d.hasParens = true;
             }
             return possibleTupleNode;
         }
@@ -3147,7 +3187,7 @@ class Parser {
             testExpr = this._tryParseLambdaExpression(/* allowConditional */ false) || this._parseOrTest();
         }
         const lambdaNode = parseNodes_1.LambdaNode.create(lambdaToken, testExpr);
-        lambdaNode.parameters = argList;
+        lambdaNode.d.params = argList;
         argList.forEach((arg) => {
             arg.parent = lambdaNode;
         });
@@ -3209,7 +3249,7 @@ class Parser {
                 });
                 (0, parseNodes_1.extendRange)(listAtom, exprListResult.list[exprListResult.list.length - 1]);
             }
-            listAtom.entries = exprListResult.list;
+            listAtom.d.items = exprListResult.list;
             return listAtom;
         }
     }
@@ -3265,8 +3305,8 @@ class Parser {
                 }
                 if (!isWalrusAllowed &&
                     keyExpression.nodeType === 4 /* ParseNodeType.AssignmentExpression */ &&
-                    !keyExpression.isParenthesized) {
-                    this._addSyntaxError(localize_1.LocMessage.walrusNotAllowed(), keyExpression.walrusToken);
+                    !keyExpression.d.hasParens) {
+                    this._addSyntaxError(localize_1.LocMessage.walrusNotAllowed(), keyExpression.d.walrusToken);
                 }
             }
             if (keyExpression && valueExpression) {
@@ -3360,12 +3400,12 @@ class Parser {
             setEntries.forEach((entry) => {
                 entry.parent = setAtom;
             });
-            setAtom.entries = setEntries;
+            setAtom.d.items = setEntries;
             return setAtom;
         }
         const dictionaryAtom = parseNodes_1.DictionaryNode.create(startBrace);
         if (trailingCommaToken) {
-            dictionaryAtom.trailingCommaToken = trailingCommaToken;
+            dictionaryAtom.d.trailingCommaToken = trailingCommaToken;
             (0, parseNodes_1.extendRange)(dictionaryAtom, trailingCommaToken);
         }
         if (closeCurlyBrace) {
@@ -3377,7 +3417,7 @@ class Parser {
             });
             (0, parseNodes_1.extendRange)(dictionaryAtom, dictionaryEntries[dictionaryEntries.length - 1]);
         }
-        dictionaryAtom.entries = dictionaryEntries;
+        dictionaryAtom.d.items = dictionaryEntries;
         return dictionaryAtom;
     }
     _parseExpressionListGeneric(parser, terminalCheck = () => this._isNextTokenNeverExpression(), finalEntryCheck = () => false) {
@@ -3493,12 +3533,12 @@ class Parser {
                 // same reason that variable type annotations don't support
                 // chained assignments. Note that a type comment was used here
                 // so it can be later reported as an error by the binder.
-                assignmentNode.chainedTypeAnnotationComment = typeAnnotationComment;
+                assignmentNode.d.chainedAnnotationComment = typeAnnotationComment;
             }
             else {
-                assignmentNode.typeAnnotationComment = typeAnnotationComment;
-                assignmentNode.typeAnnotationComment.parent = assignmentNode;
-                (0, parseNodes_1.extendRange)(assignmentNode, assignmentNode.typeAnnotationComment);
+                assignmentNode.d.annotationComment = typeAnnotationComment;
+                assignmentNode.d.annotationComment.parent = assignmentNode;
+                (0, parseNodes_1.extendRange)(assignmentNode, assignmentNode.d.annotationComment);
             }
         }
         assignmentTargets.forEach((target, index) => {
@@ -3653,7 +3693,7 @@ class Parser {
             return;
         }
         const functionAnnotation = parseResults.parseTree;
-        functionNode.functionAnnotationComment = functionAnnotation;
+        functionNode.d.funcAnnotationComment = functionAnnotation;
         functionAnnotation.parent = functionNode;
         (0, parseNodes_1.extendRange)(functionNode, functionAnnotation);
     }
@@ -3776,28 +3816,33 @@ class Parser {
         return parseNodes_1.FormatStringNode.create(startToken, endToken, middleTokens, fieldExpressions, formatExpressions);
     }
     _createBinaryOperationNode(leftExpression, rightExpression, operatorToken, operator) {
+        var _a, _b;
+        const binaryNode = parseNodes_1.BinaryOperationNode.create(leftExpression, rightExpression, operatorToken, operator);
         // Determine if we're exceeding the max parse depth. If so, replace
         // the subnode with an error node. Otherwise we risk crashing in the binder
         // or type evaluator.
-        if (leftExpression.maxChildDepth !== undefined && leftExpression.maxChildDepth >= maxChildNodeDepth) {
-            leftExpression = parseNodes_1.ErrorNode.create(leftExpression, 14 /* ErrorExpressionCategory.MaxDepthExceeded */);
-            this._addSyntaxError(localize_1.LocMessage.maxParseDepthExceeded(), leftExpression);
+        const leftMaxDepth = (_a = this._maxChildDepthMap.get(leftExpression.id)) !== null && _a !== void 0 ? _a : 0;
+        const rightMaxDepth = (_b = this._maxChildDepthMap.get(rightExpression.id)) !== null && _b !== void 0 ? _b : 0;
+        if (leftMaxDepth >= maxChildNodeDepth || rightMaxDepth >= maxChildNodeDepth) {
+            this._addSyntaxError(localize_1.LocMessage.maxParseDepthExceeded(), binaryNode);
+            return parseNodes_1.ErrorNode.create(binaryNode, 15 /* ErrorExpressionCategory.MaxDepthExceeded */);
         }
-        if (rightExpression.maxChildDepth !== undefined && rightExpression.maxChildDepth >= maxChildNodeDepth) {
-            rightExpression = parseNodes_1.ErrorNode.create(rightExpression, 14 /* ErrorExpressionCategory.MaxDepthExceeded */);
-            this._addSyntaxError(localize_1.LocMessage.maxParseDepthExceeded(), rightExpression);
-        }
-        return parseNodes_1.BinaryOperationNode.create(leftExpression, rightExpression, operatorToken, operator);
+        this._maxChildDepthMap.set(binaryNode.id, Math.max(leftMaxDepth, rightMaxDepth) + 1);
+        return binaryNode;
     }
     _createUnaryOperationNode(operatorToken, expression, operator) {
+        var _a;
+        const unaryNode = parseNodes_1.UnaryOperationNode.create(operatorToken, expression, operator);
         // Determine if we're exceeding the max parse depth. If so, replace
         // the subnode with an error node. Otherwise we risk crashing in the binder
         // or type evaluator.
-        if (expression.maxChildDepth !== undefined && expression.maxChildDepth >= maxChildNodeDepth) {
-            expression = parseNodes_1.ErrorNode.create(expression, 14 /* ErrorExpressionCategory.MaxDepthExceeded */);
-            this._addSyntaxError(localize_1.LocMessage.maxParseDepthExceeded(), expression);
+        const maxDepth = (_a = this._maxChildDepthMap.get(expression.id)) !== null && _a !== void 0 ? _a : 0;
+        if (maxDepth >= maxChildNodeDepth) {
+            this._addSyntaxError(localize_1.LocMessage.maxParseDepthExceeded(), unaryNode);
+            return parseNodes_1.ErrorNode.create(unaryNode, 15 /* ErrorExpressionCategory.MaxDepthExceeded */);
         }
-        return parseNodes_1.UnaryOperationNode.create(operatorToken, expression, operator);
+        this._maxChildDepthMap.set(unaryNode.id, maxDepth + 1);
+        return unaryNode;
     }
     _parseStringList() {
         const stringList = [];
@@ -3818,19 +3863,19 @@ class Parser {
         if (this._isParsingTypeAnnotation) {
             // Don't allow multiple strings because we have no way of reporting
             // parse errors that span strings.
-            if (stringNode.strings.length > 1) {
+            if (stringNode.d.strings.length > 1) {
                 if (this._isParsingQuotedText) {
                     this._addSyntaxError(localize_1.LocMessage.annotationSpansStrings(), stringNode);
                 }
             }
-            else if (stringNode.strings[0].nodeType === 30 /* ParseNodeType.FormatString */) {
+            else if (stringNode.d.strings[0].nodeType === 30 /* ParseNodeType.FormatString */) {
                 if (this._isParsingQuotedText) {
                     this._addSyntaxError(localize_1.LocMessage.annotationFormatString(), stringNode);
                 }
             }
             else {
-                const stringToken = stringNode.strings[0].token;
-                const stringValue = StringTokenUtils.getUnescapedString(stringNode.strings[0].token);
+                const stringToken = stringNode.d.strings[0].d.token;
+                const stringValue = StringTokenUtils.getUnescapedString(stringNode.d.strings[0].d.token);
                 const unescapedString = stringValue.value;
                 const tokenOffset = stringToken.start;
                 const prefixLength = stringToken.prefixLength + stringToken.quoteMarkLength;
@@ -3844,7 +3889,7 @@ class Parser {
                 else if ((stringToken.flags & (8 /* StringTokenFlags.Raw */ | 32 /* StringTokenFlags.Bytes */ | 64 /* StringTokenFlags.Format */)) ===
                     0) {
                     const parser = new Parser();
-                    const parseResults = parser.parseTextExpression(this._fileContents, tokenOffset + prefixLength, unescapedString.length, this._parseOptions, 1 /* ParseTextMode.VariableAnnotation */, (stringNode.strings[0].token.flags & 4 /* StringTokenFlags.Triplicate */) !== 0 ? 1 : 0, this._typingSymbolAliases);
+                    const parseResults = parser.parseTextExpression(this._fileContents, tokenOffset + prefixLength, unescapedString.length, this._parseOptions, 1 /* ParseTextMode.VariableAnnotation */, (stringNode.d.strings[0].d.token.flags & 4 /* StringTokenFlags.Triplicate */) !== 0 ? 1 : 0, this._typingSymbolAliases);
                     if (parseResults.diagnostics.length === 0 ||
                         this._parseOptions.reportErrorsForParsedStringContents) {
                         parseResults.diagnostics.forEach((diag) => {
@@ -3852,8 +3897,8 @@ class Parser {
                         });
                         if (parseResults.parseTree) {
                             (0, debug_1.assert)(parseResults.parseTree.nodeType !== 62 /* ParseNodeType.FunctionAnnotation */);
-                            stringNode.typeAnnotation = parseResults.parseTree;
-                            stringNode.typeAnnotation.parent = stringNode;
+                            stringNode.d.annotation = parseResults.parseTree;
+                            stringNode.d.annotation.parent = stringNode;
                         }
                     }
                 }
@@ -3868,13 +3913,13 @@ class Parser {
         if (possibleTupleExpr.nodeType !== 52 /* ParseNodeType.Tuple */) {
             return;
         }
-        if (possibleTupleExpr.enclosedInParens) {
+        if (possibleTupleExpr.d.hasParens) {
             return;
         }
         if (this._parseOptions.pythonVersion.isGreaterOrEqualTo(pythonVersion)) {
             return;
         }
-        for (const expr of possibleTupleExpr.expressions) {
+        for (const expr of possibleTupleExpr.d.items) {
             if (expr.nodeType === 56 /* ParseNodeType.Unpack */) {
                 this._addSyntaxError(localize_1.LocMessage.unpackTuplesIllegal(), expr);
                 return;