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

package/dist/analyzer/parseTreeUtils.js

@@ -114,8 +114,8 @@ function findNodeByOffset(node, offset) {
         if (containingChild) {
             // For augmented assignments, prefer the dest expression, which is a clone
             // of the left expression but is used to hold the type of the operation result.
-            if (node.nodeType === 5 /* ParseNodeType.AugmentedAssignment */ && containingChild === node.leftExpression) {
-                return node.destExpression;
+            if (node.nodeType === 5 /* ParseNodeType.AugmentedAssignment */ && containingChild === node.d.leftExpr) {
+                return node.d.destExpr;
             }
             return containingChild;
         }
@@ -138,7 +138,7 @@ function getClassFullName(classNode, moduleName, className) {
     while (curNode) {
         curNode = getEnclosingClass(curNode);
         if (curNode) {
-            nameParts.push(curNode.name.value);
+            nameParts.push(curNode.d.name.d.value);
         }
     }
     nameParts.push(moduleName);
@@ -155,74 +155,74 @@ function getTypeSourceId(node) {
 exports.getTypeSourceId = getTypeSourceId;
 function printArgument(node, flags) {
     let argStr = '';
-    if (node.argumentCategory === 1 /* ArgumentCategory.UnpackedList */) {
+    if (node.d.argCategory === 1 /* ArgumentCategory.UnpackedList */) {
         argStr = '*';
     }
-    else if (node.argumentCategory === 2 /* ArgumentCategory.UnpackedDictionary */) {
+    else if (node.d.argCategory === 2 /* ArgumentCategory.UnpackedDictionary */) {
         argStr = '**';
     }
-    if (node.name) {
-        argStr += node.name.value + '=';
+    if (node.d.name) {
+        argStr += node.d.name.d.value + '=';
     }
-    argStr += printExpression(node.valueExpression, flags);
+    argStr += printExpression(node.d.valueExpr, flags);
     return argStr;
 }
 exports.printArgument = printArgument;
 function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
     switch (node.nodeType) {
         case 38 /* ParseNodeType.Name */: {
-            return node.value;
+            return node.d.value;
         }
         case 35 /* ParseNodeType.MemberAccess */: {
-            return printExpression(node.leftExpression, flags) + '.' + node.memberName.value;
+            return printExpression(node.d.leftExpr, flags) + '.' + node.d.member.d.value;
         }
         case 9 /* ParseNodeType.Call */: {
-            let lhs = printExpression(node.leftExpression, flags);
+            let lhs = printExpression(node.d.leftExpr, flags);
             // Some left-hand expressions must be parenthesized.
-            if (node.leftExpression.nodeType !== 35 /* ParseNodeType.MemberAccess */ &&
-                node.leftExpression.nodeType !== 38 /* ParseNodeType.Name */ &&
-                node.leftExpression.nodeType !== 27 /* ParseNodeType.Index */ &&
-                node.leftExpression.nodeType !== 9 /* ParseNodeType.Call */) {
+            if (node.d.leftExpr.nodeType !== 35 /* ParseNodeType.MemberAccess */ &&
+                node.d.leftExpr.nodeType !== 38 /* ParseNodeType.Name */ &&
+                node.d.leftExpr.nodeType !== 27 /* ParseNodeType.Index */ &&
+                node.d.leftExpr.nodeType !== 9 /* ParseNodeType.Call */) {
                 lhs = `(${lhs})`;
             }
-            return lhs + '(' + node.arguments.map((arg) => printArgument(arg, flags)).join(', ') + ')';
+            return lhs + '(' + node.d.args.map((arg) => printArgument(arg, flags)).join(', ') + ')';
         }
         case 27 /* ParseNodeType.Index */: {
-            return (printExpression(node.baseExpression, flags) +
+            return (printExpression(node.d.leftExpr, flags) +
                 '[' +
-                node.items.map((item) => printArgument(item, flags)).join(', ') +
-                (node.trailingComma ? ',' : '') +
+                node.d.items.map((item) => printArgument(item, flags)).join(', ') +
+                (node.d.trailingComma ? ',' : '') +
                 ']');
         }
         case 55 /* ParseNodeType.UnaryOperation */: {
-            const exprStr = printOperator(node.operator) + printExpression(node.expression, flags);
-            return node.parenthesized ? `(${exprStr})` : exprStr;
+            const exprStr = printOperator(node.d.operator) + printExpression(node.d.expr, flags);
+            return node.d.hasParens ? `(${exprStr})` : exprStr;
         }
         case 7 /* ParseNodeType.BinaryOperation */: {
-            const exprStr = printExpression(node.leftExpression, flags) +
+            const exprStr = printExpression(node.d.leftExpr, flags) +
                 ' ' +
-                printOperator(node.operator) +
+                printOperator(node.d.operator) +
                 ' ' +
-                printExpression(node.rightExpression, flags);
-            return node.parenthesized ? `(${exprStr})` : exprStr;
+                printExpression(node.d.rightExpr, flags);
+            return node.d.hasParens ? `(${exprStr})` : exprStr;
         }
         case 40 /* ParseNodeType.Number */: {
-            let value = node.value.toString();
+            let value = node.d.value.toString();
             // If it's stored as a bigint, strip off the "n".
             if (value.endsWith('n')) {
                 value = value.substring(0, value.length - 1);
             }
-            if (node.isImaginary) {
+            if (node.d.isImaginary) {
                 value += 'j';
             }
             return value;
         }
         case 48 /* ParseNodeType.StringList */: {
-            if (flags & 1 /* PrintExpressionFlags.ForwardDeclarations */ && node.typeAnnotation) {
-                return printExpression(node.typeAnnotation, flags);
+            if (flags & 1 /* PrintExpressionFlags.ForwardDeclarations */ && node.d.annotation) {
+                return printExpression(node.d.annotation, flags);
             }
             else {
-                return node.strings
+                return node.d.strings
                     .map((str) => {
                     return printExpression(str, flags);
                 })
@@ -231,25 +231,25 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
         }
         case 49 /* ParseNodeType.String */: {
             let exprString = '';
-            if (node.token.flags & 8 /* StringTokenFlags.Raw */) {
+            if (node.d.token.flags & 8 /* StringTokenFlags.Raw */) {
                 exprString += 'r';
             }
-            if (node.token.flags & 16 /* StringTokenFlags.Unicode */) {
+            if (node.d.token.flags & 16 /* StringTokenFlags.Unicode */) {
                 exprString += 'u';
             }
-            if (node.token.flags & 32 /* StringTokenFlags.Bytes */) {
+            if (node.d.token.flags & 32 /* StringTokenFlags.Bytes */) {
                 exprString += 'b';
             }
-            if (node.token.flags & 64 /* StringTokenFlags.Format */) {
+            if (node.d.token.flags & 64 /* StringTokenFlags.Format */) {
                 exprString += 'f';
             }
-            let escapedString = node.token.escapedValue;
+            let escapedString = node.d.token.escapedValue;
             if ((flags & 2 /* PrintExpressionFlags.DoNotLimitStringLength */) === 0) {
                 const maxStringLength = 32;
                 escapedString = escapedString.slice(0, maxStringLength);
             }
-            if (node.token.flags & 4 /* StringTokenFlags.Triplicate */) {
-                if (node.token.flags & 1 /* StringTokenFlags.SingleQuote */) {
+            if (node.d.token.flags & 4 /* StringTokenFlags.Triplicate */) {
+                if (node.d.token.flags & 1 /* StringTokenFlags.SingleQuote */) {
                     exprString += `'''${escapedString}'''`;
                 }
                 else {
@@ -257,7 +257,7 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
                 }
             }
             else {
-                if (node.token.flags & 1 /* StringTokenFlags.SingleQuote */) {
+                if (node.d.token.flags & 1 /* StringTokenFlags.SingleQuote */) {
                     exprString += `'${escapedString}'`;
                 }
                 else {
@@ -269,7 +269,7 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
         case 30 /* ParseNodeType.FormatString */: {
             let exprString = 'f';
             let escapedString = '';
-            const itemsToPrint = [...node.middleTokens, ...node.fieldExpressions].sort((a, b) => a.start - b.start);
+            const itemsToPrint = [...node.d.middleTokens, ...node.d.fieldExprs].sort((a, b) => a.start - b.start);
             while (itemsToPrint.length > 0) {
                 const itemToPrint = itemsToPrint.shift();
                 if ('nodeType' in itemToPrint) {
@@ -279,8 +279,8 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
                     escapedString += itemToPrint.escapedValue;
                 }
             }
-            if (node.token.flags & 4 /* StringTokenFlags.Triplicate */) {
-                if (node.token.flags & 1 /* StringTokenFlags.SingleQuote */) {
+            if (node.d.token.flags & 4 /* StringTokenFlags.Triplicate */) {
+                if (node.d.token.flags & 1 /* StringTokenFlags.SingleQuote */) {
                     exprString += `'''${escapedString}'''`;
                 }
                 else {
@@ -288,7 +288,7 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
                 }
             }
             else {
-                if (node.token.flags & 1 /* StringTokenFlags.SingleQuote */) {
+                if (node.d.token.flags & 1 /* StringTokenFlags.SingleQuote */) {
                     exprString += `'${escapedString}'`;
                 }
                 else {
@@ -298,43 +298,43 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
             return exprString;
         }
         case 3 /* ParseNodeType.Assignment */: {
-            return printExpression(node.leftExpression, flags) + ' = ' + printExpression(node.rightExpression, flags);
+            return printExpression(node.d.leftExpr, flags) + ' = ' + printExpression(node.d.rightExpr, flags);
         }
         case 4 /* ParseNodeType.AssignmentExpression */: {
-            return printExpression(node.name, flags) + ' := ' + printExpression(node.rightExpression, flags);
+            return printExpression(node.d.name, flags) + ' := ' + printExpression(node.d.rightExpr, flags);
         }
         case 54 /* ParseNodeType.TypeAnnotation */: {
-            return printExpression(node.valueExpression, flags) + ': ' + printExpression(node.typeAnnotation, flags);
+            return printExpression(node.d.valueExpr, flags) + ': ' + printExpression(node.d.annotation, flags);
         }
         case 5 /* ParseNodeType.AugmentedAssignment */: {
-            return (printExpression(node.leftExpression, flags) +
+            return (printExpression(node.d.leftExpr, flags) +
                 ' ' +
-                printOperator(node.operator) +
+                printOperator(node.d.operator) +
                 ' ' +
-                printExpression(node.rightExpression, flags));
+                printExpression(node.d.rightExpr, flags));
         }
         case 6 /* ParseNodeType.Await */: {
-            const exprStr = 'await ' + printExpression(node.expression, flags);
-            return node.parenthesized ? `(${exprStr})` : exprStr;
+            const exprStr = 'await ' + printExpression(node.d.expr, flags);
+            return node.d.hasParens ? `(${exprStr})` : exprStr;
         }
         case 51 /* ParseNodeType.Ternary */: {
-            return (printExpression(node.ifExpression, flags) +
+            return (printExpression(node.d.ifExpr, flags) +
                 ' if ' +
-                printExpression(node.testExpression, flags) +
+                printExpression(node.d.testExpr, flags) +
                 ' else ' +
-                printExpression(node.elseExpression, flags));
+                printExpression(node.d.elseExpr, flags));
         }
         case 34 /* ParseNodeType.List */: {
-            const expressions = node.entries.map((expr) => {
+            const expressions = node.d.items.map((expr) => {
                 return printExpression(expr, flags);
             });
             return `[${expressions.join(', ')}]`;
         }
         case 56 /* ParseNodeType.Unpack */: {
-            return '*' + printExpression(node.expression, flags);
+            return '*' + printExpression(node.d.expr, flags);
         }
         case 52 /* ParseNodeType.Tuple */: {
-            const expressions = node.expressions.map((expr) => {
+            const expressions = node.d.items.map((expr) => {
                 return printExpression(expr, flags);
             });
             if (expressions.length === 1) {
@@ -343,57 +343,57 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
             return `(${expressions.join(', ')})`;
         }
         case 60 /* ParseNodeType.Yield */: {
-            if (node.expression) {
-                return 'yield ' + printExpression(node.expression, flags);
+            if (node.d.expr) {
+                return 'yield ' + printExpression(node.d.expr, flags);
             }
             else {
                 return 'yield';
             }
         }
         case 61 /* ParseNodeType.YieldFrom */: {
-            return 'yield from ' + printExpression(node.expression, flags);
+            return 'yield from ' + printExpression(node.d.expr, flags);
         }
         case 21 /* ParseNodeType.Ellipsis */: {
             return '...';
         }
         case 11 /* ParseNodeType.Comprehension */: {
             let listStr = '<ListExpression>';
-            if ((0, parseNodes_1.isExpressionNode)(node.expression)) {
-                listStr = printExpression(node.expression, flags);
+            if ((0, parseNodes_1.isExpressionNode)(node.d.expr)) {
+                listStr = printExpression(node.d.expr, flags);
             }
-            else if (node.expression.nodeType === 20 /* ParseNodeType.DictionaryKeyEntry */) {
-                const keyStr = printExpression(node.expression.keyExpression, flags);
-                const valueStr = printExpression(node.expression.valueExpression, flags);
+            else if (node.d.expr.nodeType === 20 /* ParseNodeType.DictionaryKeyEntry */) {
+                const keyStr = printExpression(node.d.expr.d.keyExpr, flags);
+                const valueStr = printExpression(node.d.expr.d.valueExpr, flags);
                 listStr = `${keyStr}: ${valueStr}`;
             }
             listStr =
                 listStr +
                     ' ' +
-                    node.forIfNodes
+                    node.d.forIfNodes
                         .map((expr) => {
                         if (expr.nodeType === 12 /* ParseNodeType.ComprehensionFor */) {
-                            return (`${expr.isAsync ? 'async ' : ''}for ` +
-                                printExpression(expr.targetExpression, flags) +
-                                ` in ${printExpression(expr.iterableExpression, flags)}`);
+                            return (`${expr.d.isAsync ? 'async ' : ''}for ` +
+                                printExpression(expr.d.targetExpr, flags) +
+                                ` in ${printExpression(expr.d.iterableExpr, flags)}`);
                         }
                         else {
-                            return `if ${printExpression(expr.testExpression, flags)}`;
+                            return `if ${printExpression(expr.d.testExpr, flags)}`;
                         }
                     })
                         .join(' ');
-            return node.isParenthesized ? `(${listStr})` : listStr;
+            return node.d.hasParens ? `(${listStr})` : listStr;
         }
         case 46 /* ParseNodeType.Slice */: {
             let result = '';
-            if (node.startValue || node.endValue || node.stepValue) {
-                if (node.startValue) {
-                    result += printExpression(node.startValue, flags);
+            if (node.d.startValue || node.d.endValue || node.d.stepValue) {
+                if (node.d.startValue) {
+                    result += printExpression(node.d.startValue, flags);
                 }
-                if (node.endValue) {
-                    result += ': ' + printExpression(node.endValue, flags);
+                if (node.d.endValue) {
+                    result += ': ' + printExpression(node.d.endValue, flags);
                 }
-                if (node.stepValue) {
-                    result += ': ' + printExpression(node.stepValue, flags);
+                if (node.d.stepValue) {
+                    result += ': ' + printExpression(node.d.stepValue, flags);
                 }
             }
             else {
@@ -403,53 +403,52 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
         }
         case 33 /* ParseNodeType.Lambda */: {
             return ('lambda ' +
-                node.parameters
+                node.d.params
                     .map((param) => {
                     let paramStr = '';
-                    if (param.category === 1 /* ParameterCategory.ArgsList */) {
+                    if (param.d.category === 1 /* ParameterCategory.ArgsList */) {
                         paramStr += '*';
                     }
-                    else if (param.category === 2 /* ParameterCategory.KwargsDict */) {
+                    else if (param.d.category === 2 /* ParameterCategory.KwargsDict */) {
                         paramStr += '**';
                     }
-                    if (param.name) {
-                        paramStr += param.name.value;
+                    if (param.d.name) {
+                        paramStr += param.d.name.d.value;
                     }
-                    else if (param.category === 0 /* ParameterCategory.Simple */) {
+                    else if (param.d.category === 0 /* ParameterCategory.Simple */) {
                         paramStr += '/';
                     }
-                    if (param.defaultValue) {
-                        paramStr += ' = ' + printExpression(param.defaultValue, flags);
+                    if (param.d.defaultValue) {
+                        paramStr += ' = ' + printExpression(param.d.defaultValue, flags);
                     }
                     return paramStr;
                 })
                     .join(', ') +
                 ': ' +
-                printExpression(node.expression, flags));
+                printExpression(node.d.expr, flags));
         }
         case 14 /* ParseNodeType.Constant */: {
-            if (node.constType === 33 /* KeywordType.True */) {
+            if (node.d.constType === 33 /* KeywordType.True */) {
                 return 'True';
             }
-            else if (node.constType === 15 /* KeywordType.False */) {
+            else if (node.d.constType === 15 /* KeywordType.False */) {
                 return 'False';
             }
-            else if (node.constType === 9 /* KeywordType.Debug */) {
+            else if (node.d.constType === 9 /* KeywordType.Debug */) {
                 return '__debug__';
             }
-            else if (node.constType === 26 /* KeywordType.None */) {
+            else if (node.d.constType === 26 /* KeywordType.None */) {
                 return 'None';
             }
             break;
         }
         case 18 /* ParseNodeType.Dictionary */: {
-            const dictContents = `${node.entries.map((entry) => {
+            const dictContents = `${node.d.items.map((entry) => {
                 if (entry.nodeType === 20 /* ParseNodeType.DictionaryKeyEntry */) {
-                    return (`${printExpression(entry.keyExpression, flags)}: ` +
-                        `${printExpression(entry.valueExpression, flags)}`);
+                    return (`${printExpression(entry.d.keyExpr, flags)}: ` + `${printExpression(entry.d.valueExpr, flags)}`);
                 }
                 else if (entry.nodeType === 19 /* ParseNodeType.DictionaryExpandEntry */) {
-                    return `**${printExpression(entry.expandExpression, flags)}`;
+                    return `**${printExpression(entry.d.expr, flags)}`;
                 }
                 else {
                     return printExpression(entry, flags);
@@ -461,7 +460,7 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
             return '{}';
         }
         case 45 /* ParseNodeType.Set */: {
-            return node.entries.map((entry) => printExpression(entry, flags)).join(', ');
+            return node.d.items.map((entry) => printExpression(entry, flags)).join(', ');
         }
         case 0 /* ParseNodeType.Error */: {
             return '<Parse Error>';
@@ -528,13 +527,13 @@ exports.printOperator = printOperator;
 // name in the LHS of a call expression, returns the call node.
 function getCallForName(node) {
     var _a, _b, _c;
-    if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 9 /* ParseNodeType.Call */ && node.parent.leftExpression === node) {
+    if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 9 /* ParseNodeType.Call */ && node.parent.d.leftExpr === node) {
         return node.parent;
     }
     if (((_b = node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 35 /* ParseNodeType.MemberAccess */ &&
-        node.parent.memberName === node &&
+        node.parent.d.member === node &&
         ((_c = node.parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 9 /* ParseNodeType.Call */ &&
-        node.parent.parent.leftExpression === node.parent) {
+        node.parent.parent.d.leftExpr === node.parent) {
         return node.parent.parent;
     }
     return undefined;
@@ -542,13 +541,13 @@ function getCallForName(node) {
 exports.getCallForName = getCallForName;
 function getDecoratorForName(node) {
     var _a, _b, _c;
-    if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 16 /* ParseNodeType.Decorator */ && node.parent.expression === node) {
+    if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 16 /* ParseNodeType.Decorator */ && node.parent.d.expr === node) {
         return node.parent;
     }
     if (((_b = node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 35 /* ParseNodeType.MemberAccess */ &&
-        node.parent.memberName === node &&
+        node.parent.d.member === node &&
         ((_c = node.parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 16 /* ParseNodeType.Decorator */ &&
-        node.parent.parent.expression === node.parent) {
+        node.parent.parent.d.expr === node.parent) {
         return node.parent.parent;
     }
     return undefined;
@@ -621,7 +620,7 @@ function getEnclosingFunction(node) {
     while (curNode) {
         if (curNode.nodeType === 31 /* ParseNodeType.Function */) {
             // Don't treat a decorator as being "enclosed" in the function.
-            if (!curNode.decorators.some((decorator) => decorator === prevNode)) {
+            if (!curNode.d.decorators.some((decorator) => decorator === prevNode)) {
                 return curNode;
             }
         }
@@ -740,11 +739,11 @@ function getEvaluationScopeNode(node) {
     let isParamDefaultNode = false;
     while (curNode) {
         if (curNode.nodeType === 41 /* ParseNodeType.Parameter */) {
-            if (prevNode === curNode.name) {
+            if (prevNode === curNode.d.name) {
                 // Note that we passed through a parameter name node.
                 isParamNameNode = true;
             }
-            else if (prevNode === curNode.defaultValue) {
+            else if (prevNode === curNode.d.defaultValue) {
                 // Note that we passed through a parameter default value node.
                 isParamDefaultNode = true;
             }
@@ -761,10 +760,10 @@ function getEvaluationScopeNode(node) {
                     break;
                 }
                 // Decorators are always evaluated outside of the function scope.
-                if (curNode.decorators.some((decorator) => decorator === prevNode)) {
+                if (curNode.d.decorators.some((decorator) => decorator === prevNode)) {
                     break;
                 }
-                if (curNode.parameters.some((param) => param === prevNode)) {
+                if (curNode.d.params.some((param) => param === prevNode)) {
                     // Default argument expressions are evaluated outside of the function scope.
                     if (isParamDefaultNode) {
                         break;
@@ -775,7 +774,7 @@ function getEvaluationScopeNode(node) {
                         }
                     }
                 }
-                if (prevNode === curNode.suite) {
+                if (prevNode === curNode.d.suite) {
                     if ((0, analyzerNodeInfo_1.getScope)(curNode) !== undefined) {
                         return { node: curNode };
                     }
@@ -783,8 +782,8 @@ function getEvaluationScopeNode(node) {
                 // All other nodes in the function are evaluated in the context
                 // of the type parameter scope if it's present. Otherwise,
                 // they are evaluated within the function's parent scope.
-                if (curNode.typeParameters) {
-                    const scopeNode = curNode.typeParameters;
+                if (curNode.d.typeParams) {
+                    const scopeNode = curNode.d.typeParams;
                     if ((0, analyzerNodeInfo_1.getScope)(scopeNode) !== undefined) {
                         return { node: scopeNode, useProxyScope: true };
                     }
@@ -792,14 +791,14 @@ function getEvaluationScopeNode(node) {
                 break;
             }
             case 33 /* ParseNodeType.Lambda */: {
-                if (curNode.parameters.some((param) => param === prevNode)) {
+                if (curNode.d.params.some((param) => param === prevNode)) {
                     if (isParamNameNode) {
                         if ((0, analyzerNodeInfo_1.getScope)(curNode) !== undefined) {
                             return { node: curNode };
                         }
                     }
                 }
-                else if (!prevNode || prevNode === curNode.expression) {
+                else if (!prevNode || prevNode === curNode.d.expr) {
                     if ((0, analyzerNodeInfo_1.getScope)(curNode) !== undefined) {
                         return { node: curNode };
                     }
@@ -811,10 +810,10 @@ function getEvaluationScopeNode(node) {
                     break;
                 }
                 // Decorators are always evaluated outside of the class scope.
-                if (curNode.decorators.some((decorator) => decorator === prevNode)) {
+                if (curNode.d.decorators.some((decorator) => decorator === prevNode)) {
                     break;
                 }
-                if (prevNode === curNode.suite) {
+                if (prevNode === curNode.d.suite) {
                     if ((0, analyzerNodeInfo_1.getScope)(curNode) !== undefined) {
                         return { node: curNode };
                     }
@@ -822,8 +821,8 @@ function getEvaluationScopeNode(node) {
                 // All other nodes in the class are evaluated in the context
                 // of the type parameter scope if it's present. Otherwise,
                 // they are evaluated within the class' parent scope.
-                if (curNode.typeParameters) {
-                    const scopeNode = curNode.typeParameters;
+                if (curNode.d.typeParams) {
+                    const scopeNode = curNode.d.typeParams;
                     if ((0, analyzerNodeInfo_1.getScope)(scopeNode) !== undefined) {
                         return { node: scopeNode, useProxyScope: true };
                     }
@@ -834,9 +833,9 @@ function getEvaluationScopeNode(node) {
                 if ((0, analyzerNodeInfo_1.getScope)(curNode) !== undefined) {
                     // The iterable expression of the first subnode of a list comprehension
                     // is evaluated within the scope of its parent.
-                    const isFirstIterableExpr = prevNode === curNode.forIfNodes[0] &&
-                        curNode.forIfNodes[0].nodeType === 12 /* ParseNodeType.ComprehensionFor */ &&
-                        curNode.forIfNodes[0].iterableExpression === prevPrevNode;
+                    const isFirstIterableExpr = prevNode === curNode.d.forIfNodes[0] &&
+                        curNode.d.forIfNodes[0].nodeType === 12 /* ParseNodeType.ComprehensionFor */ &&
+                        curNode.d.forIfNodes[0].d.iterableExpr === prevPrevNode;
                     if (!isFirstIterableExpr) {
                         return { node: curNode };
                     }
@@ -844,8 +843,8 @@ function getEvaluationScopeNode(node) {
                 break;
             }
             case 77 /* ParseNodeType.TypeAlias */: {
-                if (prevNode === curNode.expression && curNode.typeParameters) {
-                    const scopeNode = curNode.typeParameters;
+                if (prevNode === curNode.d.expr && curNode.d.typeParams) {
+                    const scopeNode = curNode.d.typeParams;
                     if ((0, analyzerNodeInfo_1.getScope)(scopeNode) !== undefined) {
                         return { node: scopeNode };
                     }
@@ -875,13 +874,13 @@ function getTypeVarScopeNode(node) {
     while (curNode) {
         switch (curNode.nodeType) {
             case 31 /* ParseNodeType.Function */: {
-                if (!curNode.decorators.some((decorator) => decorator === prevNode)) {
+                if (!curNode.d.decorators.some((decorator) => decorator === prevNode)) {
                     return curNode;
                 }
                 break;
             }
             case 10 /* ParseNodeType.Class */: {
-                if (!curNode.decorators.some((decorator) => decorator === prevNode)) {
+                if (!curNode.d.decorators.some((decorator) => decorator === prevNode)) {
                     return curNode;
                 }
                 break;
@@ -917,7 +916,7 @@ function getTypeAnnotationNode(node) {
     let curNode = node.parent;
     while (curNode) {
         if (curNode.nodeType === 54 /* ParseNodeType.TypeAnnotation */) {
-            if (curNode.typeAnnotation === prevNode) {
+            if (curNode.d.annotation === prevNode) {
                 return curNode;
             }
             break;
@@ -932,8 +931,8 @@ exports.getTypeAnnotationNode = getTypeAnnotationNode;
 // left-to-right order. There is one exception, however, when an unpacked
 // iterable is used after a keyword argument.
 function getArgumentsByRuntimeOrder(node) {
-    const positionalArgs = node.arguments.filter((arg) => !arg.name && arg.argumentCategory !== 2 /* ArgumentCategory.UnpackedDictionary */);
-    const keywordArgs = node.arguments.filter((arg) => !!arg.name || arg.argumentCategory === 2 /* ArgumentCategory.UnpackedDictionary */);
+    const positionalArgs = node.d.args.filter((arg) => !arg.d.name && arg.d.argCategory !== 2 /* ArgumentCategory.UnpackedDictionary */);
+    const keywordArgs = node.d.args.filter((arg) => !!arg.d.name || arg.d.argCategory === 2 /* ArgumentCategory.UnpackedDictionary */);
     return positionalArgs.concat(keywordArgs);
 }
 exports.getArgumentsByRuntimeOrder = getArgumentsByRuntimeOrder;
@@ -948,7 +947,7 @@ function isFinalAllowedForAssignmentTarget(targetNode) {
     // Member access expressions like "self.x" are permitted only
     // within __init__ methods.
     if (targetNode.nodeType === 35 /* ParseNodeType.MemberAccess */) {
-        if (targetNode.leftExpression.nodeType !== 38 /* ParseNodeType.Name */) {
+        if (targetNode.d.leftExpr.nodeType !== 38 /* ParseNodeType.Name */) {
             return false;
         }
         const classNode = getEnclosingClass(targetNode);
@@ -959,7 +958,7 @@ function isFinalAllowedForAssignmentTarget(targetNode) {
         if (!methodNode) {
             return false;
         }
-        if (methodNode.name.value !== '__init__') {
+        if (methodNode.d.name.d.value !== '__init__') {
             return false;
         }
         return true;
@@ -1012,31 +1011,31 @@ function getParentAnnotationNode(node) {
     let prevNode;
     while (curNode) {
         if (curNode.nodeType === 31 /* ParseNodeType.Function */) {
-            if (prevNode === curNode.returnTypeAnnotation) {
+            if (prevNode === curNode.d.returnAnnotation) {
                 return prevNode;
             }
             return undefined;
         }
         if (curNode.nodeType === 41 /* ParseNodeType.Parameter */) {
-            if (prevNode === curNode.typeAnnotation || prevNode === curNode.typeAnnotationComment) {
+            if (prevNode === curNode.d.annotation || prevNode === curNode.d.annotationComment) {
                 return prevNode;
             }
             return undefined;
         }
         if (curNode.nodeType === 3 /* ParseNodeType.Assignment */) {
-            if (prevNode === curNode.typeAnnotationComment) {
+            if (prevNode === curNode.d.annotationComment) {
                 return prevNode;
             }
             return undefined;
         }
         if (curNode.nodeType === 54 /* ParseNodeType.TypeAnnotation */) {
-            if (prevNode === curNode.typeAnnotation) {
+            if (prevNode === curNode.d.annotation) {
                 return prevNode;
             }
             return undefined;
         }
         if (curNode.nodeType === 62 /* ParseNodeType.FunctionAnnotation */) {
-            if (prevNode === curNode.returnTypeAnnotation || curNode.paramTypeAnnotations.some((p) => p === prevNode)) {
+            if (prevNode === curNode.d.returnAnnotation || curNode.d.paramAnnotations.some((p) => p === prevNode)) {
                 (0, debug_1.assert)(!prevNode || (0, parseNodes_1.isExpressionNode)(prevNode));
                 return prevNode;
             }
@@ -1054,9 +1053,9 @@ function isNodeContainedWithinNodeType(node, containerType) {
 exports.isNodeContainedWithinNodeType = isNodeContainedWithinNodeType;
 function isSuiteEmpty(node) {
     let sawEllipsis = false;
-    for (const statement of node.statements) {
+    for (const statement of node.d.statements) {
         if (statement.nodeType === 47 /* ParseNodeType.StatementList */) {
-            for (const substatement of statement.statements) {
+            for (const substatement of statement.d.statements) {
                 if (substatement.nodeType === 21 /* ParseNodeType.Ellipsis */) {
                     // Allow an ellipsis
                     sawEllipsis = true;
@@ -1092,60 +1091,60 @@ exports.containsAwaitNode = containsAwaitNode;
 function isMatchingExpression(reference, expression) {
     if (reference.nodeType === 38 /* ParseNodeType.Name */) {
         if (expression.nodeType === 38 /* ParseNodeType.Name */) {
-            return reference.value === expression.value;
+            return reference.d.value === expression.d.value;
         }
         else if (expression.nodeType === 4 /* ParseNodeType.AssignmentExpression */) {
-            return reference.value === expression.name.value;
+            return reference.d.value === expression.d.name.d.value;
         }
         return false;
     }
     else if (reference.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
         expression.nodeType === 35 /* ParseNodeType.MemberAccess */) {
-        return (isMatchingExpression(reference.leftExpression, expression.leftExpression) &&
-            reference.memberName.value === expression.memberName.value);
+        return (isMatchingExpression(reference.d.leftExpr, expression.d.leftExpr) &&
+            reference.d.member.d.value === expression.d.member.d.value);
     }
     else if (reference.nodeType === 27 /* ParseNodeType.Index */ && expression.nodeType === 27 /* ParseNodeType.Index */) {
-        if (!isMatchingExpression(reference.baseExpression, expression.baseExpression)) {
+        if (!isMatchingExpression(reference.d.leftExpr, expression.d.leftExpr)) {
             return false;
         }
-        if (expression.items.length !== 1 ||
-            expression.trailingComma ||
-            expression.items[0].name ||
-            expression.items[0].argumentCategory !== 0 /* ArgumentCategory.Simple */) {
+        if (expression.d.items.length !== 1 ||
+            expression.d.trailingComma ||
+            expression.d.items[0].d.name ||
+            expression.d.items[0].d.argCategory !== 0 /* ArgumentCategory.Simple */) {
             return false;
         }
-        const expr = reference.items[0].valueExpression;
+        const expr = reference.d.items[0].d.valueExpr;
         if (expr.nodeType === 40 /* ParseNodeType.Number */) {
-            const subscriptNode = expression.items[0].valueExpression;
+            const subscriptNode = expression.d.items[0].d.valueExpr;
             if (subscriptNode.nodeType !== 40 /* ParseNodeType.Number */ ||
-                subscriptNode.isImaginary ||
-                !subscriptNode.isInteger) {
+                subscriptNode.d.isImaginary ||
+                !subscriptNode.d.isInteger) {
                 return false;
             }
-            return expr.value === subscriptNode.value;
+            return expr.d.value === subscriptNode.d.value;
         }
         if (expr.nodeType === 55 /* ParseNodeType.UnaryOperation */ &&
-            expr.operator === 33 /* OperatorType.Subtract */ &&
-            expr.expression.nodeType === 40 /* ParseNodeType.Number */) {
-            const subscriptNode = expression.items[0].valueExpression;
+            expr.d.operator === 33 /* OperatorType.Subtract */ &&
+            expr.d.expr.nodeType === 40 /* ParseNodeType.Number */) {
+            const subscriptNode = expression.d.items[0].d.valueExpr;
             if (subscriptNode.nodeType !== 55 /* ParseNodeType.UnaryOperation */ ||
-                subscriptNode.operator !== 33 /* OperatorType.Subtract */ ||
-                subscriptNode.expression.nodeType !== 40 /* ParseNodeType.Number */ ||
-                subscriptNode.expression.isImaginary ||
-                !subscriptNode.expression.isInteger) {
+                subscriptNode.d.operator !== 33 /* OperatorType.Subtract */ ||
+                subscriptNode.d.expr.nodeType !== 40 /* ParseNodeType.Number */ ||
+                subscriptNode.d.expr.d.isImaginary ||
+                !subscriptNode.d.expr.d.isInteger) {
                 return false;
             }
-            return expr.expression.value === subscriptNode.expression.value;
+            return expr.d.expr.d.value === subscriptNode.d.expr.d.value;
         }
         if (expr.nodeType === 48 /* ParseNodeType.StringList */) {
             const referenceStringListNode = expr;
-            const subscriptNode = expression.items[0].valueExpression;
-            if (referenceStringListNode.strings.length === 1 &&
-                referenceStringListNode.strings[0].nodeType === 49 /* ParseNodeType.String */ &&
+            const subscriptNode = expression.d.items[0].d.valueExpr;
+            if (referenceStringListNode.d.strings.length === 1 &&
+                referenceStringListNode.d.strings[0].nodeType === 49 /* ParseNodeType.String */ &&
                 subscriptNode.nodeType === 48 /* ParseNodeType.StringList */ &&
-                subscriptNode.strings.length === 1 &&
-                subscriptNode.strings[0].nodeType === 49 /* ParseNodeType.String */) {
-                return referenceStringListNode.strings[0].value === subscriptNode.strings[0].value;
+                subscriptNode.d.strings.length === 1 &&
+                subscriptNode.d.strings[0].nodeType === 49 /* ParseNodeType.String */) {
+                return referenceStringListNode.d.strings[0].d.value === subscriptNode.d.strings[0].d.value;
             }
         }
         return false;
@@ -1155,12 +1154,12 @@ function isMatchingExpression(reference, expression) {
 exports.isMatchingExpression = isMatchingExpression;
 function isPartialMatchingExpression(reference, expression) {
     if (reference.nodeType === 35 /* ParseNodeType.MemberAccess */) {
-        return (isMatchingExpression(reference.leftExpression, expression) ||
-            isPartialMatchingExpression(reference.leftExpression, expression));
+        return (isMatchingExpression(reference.d.leftExpr, expression) ||
+            isPartialMatchingExpression(reference.d.leftExpr, expression));
     }
     else if (reference.nodeType === 27 /* ParseNodeType.Index */) {
-        return (isMatchingExpression(reference.baseExpression, expression) ||
-            isPartialMatchingExpression(reference.baseExpression, expression));
+        return (isMatchingExpression(reference.d.leftExpr, expression) ||
+            isPartialMatchingExpression(reference.d.leftExpr, expression));
     }
     return false;
 }
@@ -1169,7 +1168,7 @@ function isWithinDefaultParamInitializer(node) {
     let curNode = node;
     let prevNode;
     while (curNode) {
-        if (curNode.nodeType === 41 /* ParseNodeType.Parameter */ && prevNode === curNode.defaultValue) {
+        if (curNode.nodeType === 41 /* ParseNodeType.Parameter */ && prevNode === curNode.d.defaultValue) {
             return true;
         }
         if (curNode.nodeType === 33 /* ParseNodeType.Lambda */ ||
@@ -1190,26 +1189,26 @@ function isWithinTypeAnnotation(node, requireQuotedAnnotation) {
     let isQuoted = false;
     while (curNode) {
         if (curNode.nodeType === 41 /* ParseNodeType.Parameter */ &&
-            (prevNode === curNode.typeAnnotation || prevNode === curNode.typeAnnotationComment)) {
+            (prevNode === curNode.d.annotation || prevNode === curNode.d.annotationComment)) {
             return isQuoted || !requireQuotedAnnotation;
         }
-        if (curNode.nodeType === 31 /* ParseNodeType.Function */ && prevNode === curNode.returnTypeAnnotation) {
+        if (curNode.nodeType === 31 /* ParseNodeType.Function */ && prevNode === curNode.d.returnAnnotation) {
             return isQuoted || !requireQuotedAnnotation;
         }
-        if (curNode.nodeType === 31 /* ParseNodeType.Function */ && prevNode === curNode.functionAnnotationComment) {
+        if (curNode.nodeType === 31 /* ParseNodeType.Function */ && prevNode === curNode.d.funcAnnotationComment) {
             // Type comments are always considered forward declarations even though
             // they're not "quoted".
             return true;
         }
-        if (curNode.nodeType === 54 /* ParseNodeType.TypeAnnotation */ && prevNode === curNode.typeAnnotation) {
+        if (curNode.nodeType === 54 /* ParseNodeType.TypeAnnotation */ && prevNode === curNode.d.annotation) {
             return isQuoted || !requireQuotedAnnotation;
         }
-        if (curNode.nodeType === 3 /* ParseNodeType.Assignment */ && prevNode === curNode.typeAnnotationComment) {
+        if (curNode.nodeType === 3 /* ParseNodeType.Assignment */ && prevNode === curNode.d.annotationComment) {
             // Type comments are always considered forward declarations even though
             // they're not "quoted".
             return true;
         }
-        if (curNode.nodeType === 48 /* ParseNodeType.StringList */ && prevNode === curNode.typeAnnotation) {
+        if (curNode.nodeType === 48 /* ParseNodeType.StringList */ && prevNode === curNode.d.annotation) {
             isQuoted = true;
         }
         if (curNode.nodeType === 33 /* ParseNodeType.Lambda */ ||
@@ -1228,12 +1227,12 @@ function isWithinAnnotationComment(node) {
     let curNode = node;
     let prevNode;
     while (curNode) {
-        if (curNode.nodeType === 31 /* ParseNodeType.Function */ && prevNode === curNode.functionAnnotationComment) {
+        if (curNode.nodeType === 31 /* ParseNodeType.Function */ && prevNode === curNode.d.funcAnnotationComment) {
             // Type comments are always considered forward declarations even though
             // they're not "quoted".
             return true;
         }
-        if (curNode.nodeType === 3 /* ParseNodeType.Assignment */ && prevNode === curNode.typeAnnotationComment) {
+        if (curNode.nodeType === 3 /* ParseNodeType.Assignment */ && prevNode === curNode.d.annotationComment) {
             // Type comments are always considered forward declarations even though
             // they're not "quoted".
             return true;
@@ -1273,7 +1272,7 @@ function isWithinAssertExpression(node) {
     while (curNode) {
         switch (curNode.nodeType) {
             case 2 /* ParseNodeType.Assert */: {
-                return curNode.testExpression === prevNode;
+                return curNode.d.testExpr === prevNode;
             }
         }
         prevNode = curNode;
@@ -1294,21 +1293,22 @@ function getDocString(statements) {
         return undefined;
     }
     // It's up to the user to convert normalize/convert this as needed.
-    const strings = statements[0].statements[0].strings;
+    const strings = statements[0].d.statements[0].d.strings;
     if (strings.length === 1) {
-        return strings[0].value;
+        return strings[0].d.value;
     }
-    return strings.map((s) => s.value).join('');
+    return strings.map((s) => s.d.value).join('');
 }
 exports.getDocString = getDocString;
 function isDocString(statementList) {
     // If the first statement in the suite isn't a StringNode,
     // assume there is no docString.
-    if (statementList.statements.length === 0 || statementList.statements[0].nodeType !== 48 /* ParseNodeType.StringList */) {
+    if (statementList.d.statements.length === 0 ||
+        statementList.d.statements[0].nodeType !== 48 /* ParseNodeType.StringList */) {
         return false;
     }
     // A docstring can consist of multiple joined strings in a single expression.
-    const strings = statementList.statements[0].strings;
+    const strings = statementList.d.statements[0].d.strings;
     if (strings.length === 0) {
         return false;
     }
@@ -1330,44 +1330,44 @@ function isAssignmentToDefaultsFollowingNamedTuple(callNode) {
     if (callNode.nodeType !== 9 /* ParseNodeType.Call */ ||
         !callNode.parent ||
         callNode.parent.nodeType !== 3 /* ParseNodeType.Assignment */ ||
-        callNode.parent.leftExpression.nodeType !== 38 /* ParseNodeType.Name */ ||
+        callNode.parent.d.leftExpr.nodeType !== 38 /* ParseNodeType.Name */ ||
         !callNode.parent.parent ||
         callNode.parent.parent.nodeType !== 47 /* ParseNodeType.StatementList */) {
         return false;
     }
-    const namedTupleAssignedName = callNode.parent.leftExpression.value;
+    const namedTupleAssignedName = callNode.parent.d.leftExpr.d.value;
     const statementList = callNode.parent.parent;
-    if (statementList.statements[0] !== callNode.parent ||
+    if (statementList.d.statements[0] !== callNode.parent ||
         !statementList.parent ||
         !(statementList.parent.nodeType === 36 /* ParseNodeType.Module */ ||
             statementList.parent.nodeType === 50 /* ParseNodeType.Suite */)) {
         return false;
     }
     const moduleOrSuite = statementList.parent;
-    let statementIndex = moduleOrSuite.statements.findIndex((s) => s === statementList);
+    let statementIndex = moduleOrSuite.d.statements.findIndex((s) => s === statementList);
     if (statementIndex < 0) {
         return false;
     }
     statementIndex++;
-    while (statementIndex < moduleOrSuite.statements.length) {
-        const nextStatement = moduleOrSuite.statements[statementIndex];
+    while (statementIndex < moduleOrSuite.d.statements.length) {
+        const nextStatement = moduleOrSuite.d.statements[statementIndex];
         if (nextStatement.nodeType !== 47 /* ParseNodeType.StatementList */) {
             break;
         }
-        if (((_a = nextStatement.statements[0]) === null || _a === void 0 ? void 0 : _a.nodeType) === 48 /* ParseNodeType.StringList */) {
+        if (((_a = nextStatement.d.statements[0]) === null || _a === void 0 ? void 0 : _a.nodeType) === 48 /* ParseNodeType.StringList */) {
             // Skip over comments
             statementIndex++;
             continue;
         }
-        if (((_b = nextStatement.statements[0]) === null || _b === void 0 ? void 0 : _b.nodeType) === 3 /* ParseNodeType.Assignment */) {
-            const assignNode = nextStatement.statements[0];
-            if (assignNode.leftExpression.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
-                assignNode.leftExpression.memberName.value === '__defaults__') {
-                const defaultTarget = assignNode.leftExpression.leftExpression;
+        if (((_b = nextStatement.d.statements[0]) === null || _b === void 0 ? void 0 : _b.nodeType) === 3 /* ParseNodeType.Assignment */) {
+            const assignNode = nextStatement.d.statements[0];
+            if (assignNode.d.leftExpr.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
+                assignNode.d.leftExpr.d.member.d.value === '__defaults__') {
+                const defaultTarget = assignNode.d.leftExpr.d.leftExpr;
                 if (defaultTarget.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
-                    defaultTarget.memberName.value === '__new__' &&
-                    defaultTarget.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
-                    defaultTarget.leftExpression.value === namedTupleAssignedName) {
+                    defaultTarget.d.member.d.value === '__new__' &&
+                    defaultTarget.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ &&
+                    defaultTarget.d.leftExpr.d.value === namedTupleAssignedName) {
                     return true;
                 }
             }
@@ -1389,11 +1389,11 @@ class NameNodeWalker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitIndex(node) {
-        this.walk(node.baseExpression);
+        this.walk(node.d.leftExpr);
         const prevSubscriptIndex = this._subscriptIndex;
         const prevBaseExpression = this._baseExpression;
-        this._baseExpression = node.baseExpression;
-        node.items.forEach((item, index) => {
+        this._baseExpression = node.d.leftExpr;
+        node.d.items.forEach((item, index) => {
             this._subscriptIndex = index;
             this.walk(item);
         });
@@ -1442,7 +1442,7 @@ function getCallNodeAndActiveParameterIndex(node, insertionOffset, tokens) {
         }
         curNode = curNode.parent;
     }
-    if (!callNode || !callNode.arguments) {
+    if (!callNode || !callNode.d.args) {
         return undefined;
     }
     const endPosition = textRange_1.TextRange.getEnd(callNode);
@@ -1456,7 +1456,7 @@ function getCallNodeAndActiveParameterIndex(node, insertionOffset, tokens) {
     let addedActive = false;
     let activeIndex = -1;
     let activeOrFake = false;
-    callNode.arguments.forEach((arg, index) => {
+    callNode.d.args.forEach((arg, index) => {
         if (addedActive) {
             return;
         }
@@ -1491,7 +1491,7 @@ function getCallNodeAndActiveParameterIndex(node, insertionOffset, tokens) {
         }
     });
     if (!addedActive) {
-        activeIndex = callNode.arguments.length + 1;
+        activeIndex = callNode.d.args.length + 1;
     }
     return {
         callNode,
@@ -1499,15 +1499,15 @@ function getCallNodeAndActiveParameterIndex(node, insertionOffset, tokens) {
         activeOrFake,
     };
     function isOffsetInsideCallArgs(tokens, node, offset) {
-        const argumentStart = node.leftExpression.length > 0 ? textRange_1.TextRange.getEnd(node.leftExpression) - 1 : node.leftExpression.start;
+        const argumentStart = node.d.leftExpr.length > 0 ? textRange_1.TextRange.getEnd(node.d.leftExpr) - 1 : node.d.leftExpr.start;
         // Handle obvious case first.
         const callEndOffset = textRange_1.TextRange.getEnd(node);
         if (offset < argumentStart || callEndOffset < offset) {
             return false;
         }
-        if (node.arguments.length > 0) {
-            const start = node.arguments[0].start;
-            const end = textRange_1.TextRange.getEnd(node.arguments[node.arguments.length - 1]);
+        if (node.d.args.length > 0) {
+            const start = node.d.args[0].start;
+            const end = textRange_1.TextRange.getEnd(node.d.args[node.d.args.length - 1]);
             if (start <= offset && offset < end) {
                 return true;
             }
@@ -1786,44 +1786,44 @@ function isWriteAccess(node) {
     while (curNode) {
         switch (curNode.nodeType) {
             case 3 /* ParseNodeType.Assignment */: {
-                return prevNode === curNode.leftExpression;
+                return prevNode === curNode.d.leftExpr;
             }
             case 5 /* ParseNodeType.AugmentedAssignment */: {
-                return prevNode === curNode.leftExpression;
+                return prevNode === curNode.d.leftExpr;
             }
             case 4 /* ParseNodeType.AssignmentExpression */: {
-                return prevNode === curNode.name;
+                return prevNode === curNode.d.name;
             }
             case 17 /* ParseNodeType.Del */: {
                 return true;
             }
             case 29 /* ParseNodeType.For */: {
-                return prevNode === curNode.targetExpression;
+                return prevNode === curNode.d.targetExpr;
             }
             case 24 /* ParseNodeType.ImportAs */: {
-                return (prevNode === curNode.alias ||
-                    (curNode.module.nameParts.length > 0 && prevNode === curNode.module.nameParts[0]));
+                return (prevNode === curNode.d.alias ||
+                    (curNode.d.module.d.nameParts.length > 0 && prevNode === curNode.d.module.d.nameParts[0]));
             }
             case 26 /* ParseNodeType.ImportFromAs */: {
-                return prevNode === curNode.alias || (!curNode.alias && prevNode === curNode.name);
+                return prevNode === curNode.d.alias || (!curNode.d.alias && prevNode === curNode.d.name);
             }
             case 35 /* ParseNodeType.MemberAccess */: {
-                if (prevNode !== curNode.memberName) {
+                if (prevNode !== curNode.d.member) {
                     return false;
                 }
                 break;
             }
             case 28 /* ParseNodeType.Except */: {
-                return prevNode === curNode.name;
+                return prevNode === curNode.d.name;
             }
             case 58 /* ParseNodeType.With */: {
-                return curNode.withItems.some((item) => item === prevNode);
+                return curNode.d.withItems.some((item) => item === prevNode);
             }
             case 12 /* ParseNodeType.ComprehensionFor */: {
-                return prevNode === curNode.targetExpression;
+                return prevNode === curNode.d.targetExpr;
             }
             case 54 /* ParseNodeType.TypeAnnotation */: {
-                if (prevNode === curNode.typeAnnotation) {
+                if (prevNode === curNode.d.annotation) {
                     return false;
                 }
                 break;
@@ -1855,12 +1855,12 @@ function getFileInfoFromNode(node) {
 exports.getFileInfoFromNode = getFileInfoFromNode;
 function isFunctionSuiteEmpty(node) {
     let isEmpty = true;
-    node.suite.statements.forEach((statement) => {
+    node.d.suite.d.statements.forEach((statement) => {
         if (statement.nodeType === 0 /* ParseNodeType.Error */) {
             return;
         }
         else if (statement.nodeType === 47 /* ParseNodeType.StatementList */) {
-            statement.statements.forEach((subStatement) => {
+            statement.d.statements.forEach((subStatement) => {
                 // Allow docstrings, ellipsis, and pass statements.
                 if (subStatement.nodeType !== 21 /* ParseNodeType.Ellipsis */ &&
                     subStatement.nodeType !== 48 /* ParseNodeType.StringList */ &&
@@ -1877,22 +1877,22 @@ function isFunctionSuiteEmpty(node) {
 }
 exports.isFunctionSuiteEmpty = isFunctionSuiteEmpty;
 function getTypeAnnotationForParameter(node, paramIndex) {
-    if (paramIndex >= node.parameters.length) {
+    if (paramIndex >= node.d.params.length) {
         return undefined;
     }
-    const param = node.parameters[paramIndex];
-    if (param.typeAnnotation) {
-        return param.typeAnnotation;
+    const param = node.d.params[paramIndex];
+    if (param.d.annotation) {
+        return param.d.annotation;
     }
-    else if (param.typeAnnotationComment) {
-        return param.typeAnnotationComment;
+    else if (param.d.annotationComment) {
+        return param.d.annotationComment;
     }
-    if (!node.functionAnnotationComment || node.functionAnnotationComment.isParamListEllipsis) {
+    if (!node.d.funcAnnotationComment || node.d.funcAnnotationComment.d.isEllipsis) {
         return undefined;
     }
     let firstCommentAnnotationIndex = 0;
-    const paramAnnotations = node.functionAnnotationComment.paramTypeAnnotations;
-    if (paramAnnotations.length < node.parameters.length) {
+    const paramAnnotations = node.d.funcAnnotationComment.d.paramAnnotations;
+    if (paramAnnotations.length < node.d.params.length) {
         firstCommentAnnotationIndex = 1;
     }
     const adjIndex = paramIndex - firstCommentAnnotationIndex;
@@ -1909,7 +1909,7 @@ function isImportModuleName(node) {
 exports.isImportModuleName = isImportModuleName;
 function isImportAlias(node) {
     var _a;
-    return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 24 /* ParseNodeType.ImportAs */ && node.parent.alias === node;
+    return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 24 /* ParseNodeType.ImportAs */ && node.parent.d.alias === node;
 }
 exports.isImportAlias = isImportAlias;
 function isFromImportModuleName(node) {
@@ -1919,12 +1919,12 @@ function isFromImportModuleName(node) {
 exports.isFromImportModuleName = isFromImportModuleName;
 function isFromImportName(node) {
     var _a;
-    return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 26 /* ParseNodeType.ImportFromAs */ && node.parent.name === node;
+    return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 26 /* ParseNodeType.ImportFromAs */ && node.parent.d.name === node;
 }
 exports.isFromImportName = isFromImportName;
 function isFromImportAlias(node) {
     var _a;
-    return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 26 /* ParseNodeType.ImportFromAs */ && node.parent.alias === node;
+    return ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 26 /* ParseNodeType.ImportFromAs */ && node.parent.d.alias === node;
 }
 exports.isFromImportAlias = isFromImportAlias;
 function isLastNameOfModuleName(node) {
@@ -1933,10 +1933,10 @@ function isLastNameOfModuleName(node) {
         return false;
     }
     const module = node.parent;
-    if (module.nameParts.length === 0) {
+    if (module.d.nameParts.length === 0) {
         return false;
     }
-    return module.nameParts[module.nameParts.length - 1] === node;
+    return module.d.nameParts[module.d.nameParts.length - 1] === node;
 }
 exports.isLastNameOfModuleName = isLastNameOfModuleName;
 function* getAncestorsIncludingSelf(node) {
@@ -1971,7 +1971,7 @@ function getDottedNameWithGivenNodeAsLastName(node) {
     if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 35 /* ParseNodeType.MemberAccess */) {
         return node;
     }
-    if (node.parent.leftExpression === node) {
+    if (node.parent.d.leftExpr === node) {
         return node;
     }
     return node.parent;
@@ -1989,14 +1989,14 @@ function getDecoratorName(decorator) {
     function getExpressionName(node) {
         var _a;
         if (node.nodeType === 38 /* ParseNodeType.Name */ || node.nodeType === 35 /* ParseNodeType.MemberAccess */) {
-            return (_a = getDottedName(node)) === null || _a === void 0 ? void 0 : _a.map((n) => n.value).join('.');
+            return (_a = getDottedName(node)) === null || _a === void 0 ? void 0 : _a.map((n) => n.d.value).join('.');
         }
         if (node.nodeType === 9 /* ParseNodeType.Call */) {
-            return getExpressionName(node.leftExpression);
+            return getExpressionName(node.d.leftExpr);
         }
         return undefined;
     }
-    return getExpressionName(decorator.expression);
+    return getExpressionName(decorator.d.expr);
 }
 exports.getDecoratorName = getDecoratorName;
 function getDottedName(node) {
@@ -2016,10 +2016,10 @@ function getDottedName(node) {
             names.push(node);
             return true;
         }
-        names.push(node.memberName);
-        if (node.leftExpression.nodeType === 38 /* ParseNodeType.Name */ ||
-            node.leftExpression.nodeType === 35 /* ParseNodeType.MemberAccess */) {
-            return _getDottedName(node.leftExpression, names);
+        names.push(node.d.member);
+        if (node.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ ||
+            node.d.leftExpr.nodeType === 35 /* ParseNodeType.MemberAccess */) {
+            return _getDottedName(node.d.leftExpr, names);
         }
         return false;
     }
@@ -2030,9 +2030,8 @@ function getFirstNameOfDottedName(node) {
     if (node.nodeType === 38 /* ParseNodeType.Name */) {
         return node;
     }
-    if (node.leftExpression.nodeType === 38 /* ParseNodeType.Name */ ||
-        node.leftExpression.nodeType === 35 /* ParseNodeType.MemberAccess */) {
-        return getFirstNameOfDottedName(node.leftExpression);
+    if (node.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ || node.d.leftExpr.nodeType === 35 /* ParseNodeType.MemberAccess */) {
+        return getFirstNameOfDottedName(node.d.leftExpr);
     }
     return undefined;
 }
@@ -2043,7 +2042,7 @@ function isFirstNameOfDottedName(node) {
     if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 35 /* ParseNodeType.MemberAccess */) {
         return true;
     }
-    if (node.parent.leftExpression === node) {
+    if (node.parent.d.leftExpr === node) {
         return true;
     }
     return false;
@@ -2055,18 +2054,18 @@ function isLastNameOfDottedName(node) {
     if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 35 /* ParseNodeType.MemberAccess */) {
         return true;
     }
-    if (node.parent.leftExpression.nodeType !== 38 /* ParseNodeType.Name */ &&
-        node.parent.leftExpression.nodeType !== 35 /* ParseNodeType.MemberAccess */) {
+    if (node.parent.d.leftExpr.nodeType !== 38 /* ParseNodeType.Name */ &&
+        node.parent.d.leftExpr.nodeType !== 35 /* ParseNodeType.MemberAccess */) {
         return false;
     }
-    if (node.parent.leftExpression === node) {
+    if (node.parent.d.leftExpr === node) {
         return false;
     }
     return ((_b = node.parent.parent) === null || _b === void 0 ? void 0 : _b.nodeType) !== 35 /* ParseNodeType.MemberAccess */;
 }
 exports.isLastNameOfDottedName = isLastNameOfDottedName;
 function getStringNodeValueRange(node) {
-    return getStringValueRange(node.token);
+    return getStringValueRange(node.d.token);
 }
 exports.getStringNodeValueRange = getStringNodeValueRange;
 function getStringValueRange(token) {
@@ -2111,8 +2110,8 @@ function isBlankLine(tokenizerOutput, text, line) {
 }
 exports.isBlankLine = isBlankLine;
 function isUnannotatedFunction(node) {
-    return (node.returnTypeAnnotation === undefined &&
-        node.parameters.every((param) => param.typeAnnotation === undefined && param.typeAnnotationComment === undefined));
+    return (node.d.returnAnnotation === undefined &&
+        node.d.params.every((param) => param.d.annotation === undefined && param.d.annotationComment === undefined));
 }
 exports.isUnannotatedFunction = isUnannotatedFunction;
 // Verifies that an import of the form "from __future__ import x"
@@ -2122,11 +2121,11 @@ function isValidLocationForFutureImport(node) {
     const module = getModuleNode(node);
     (0, debug_1.assert)(module);
     let sawDocString = false;
-    for (const statement of module.statements) {
+    for (const statement of module.d.statements) {
         if (statement.nodeType !== 47 /* ParseNodeType.StatementList */) {
             return false;
         }
-        for (const simpleStatement of statement.statements) {
+        for (const simpleStatement of statement.d.statements) {
             if (simpleStatement === node) {
                 return true;
             }
@@ -2137,9 +2136,9 @@ function isValidLocationForFutureImport(node) {
                 sawDocString = true;
             }
             else if (simpleStatement.nodeType === 25 /* ParseNodeType.ImportFrom */) {
-                if (simpleStatement.module.leadingDots !== 0 ||
-                    simpleStatement.module.nameParts.length !== 1 ||
-                    simpleStatement.module.nameParts[0].value !== '__future__') {
+                if (simpleStatement.d.module.d.leadingDots !== 0 ||
+                    simpleStatement.d.module.d.nameParts.length !== 1 ||
+                    simpleStatement.d.module.d.nameParts[0].d.value !== '__future__') {
                     return false;
                 }
             }
@@ -2277,11 +2276,11 @@ function getVariableDocStringNode(node) {
         (suiteOrModule.nodeType !== 36 /* ParseNodeType.Module */ && suiteOrModule.nodeType !== 50 /* ParseNodeType.Suite */)) {
         return undefined;
     }
-    const assignmentIndex = suiteOrModule.statements.findIndex((node) => node === parentNode);
-    if (assignmentIndex < 0 || assignmentIndex === suiteOrModule.statements.length - 1) {
+    const assignmentIndex = suiteOrModule.d.statements.findIndex((node) => node === parentNode);
+    if (assignmentIndex < 0 || assignmentIndex === suiteOrModule.d.statements.length - 1) {
         return undefined;
     }
-    const nextStatement = suiteOrModule.statements[assignmentIndex + 1];
+    const nextStatement = suiteOrModule.d.statements[assignmentIndex + 1];
     if (nextStatement.nodeType !== 47 /* ParseNodeType.StatementList */ || !isDocString(nextStatement)) {
         return undefined;
     }
@@ -2299,7 +2298,7 @@ function getVariableDocStringNode(node) {
     else {
         const func = getEnclosingFunction(parentNode);
         // If we're within an __init__ method, the attribute docstring is valid.
-        if (func && func.name.value === '__init__' && getEnclosingClass(func, /* stopAtFunction */ true)) {
+        if (func && func.d.name.d.value === '__init__' && getEnclosingClass(func, /* stopAtFunction */ true)) {
             isValidContext = true;
         }
     }
@@ -2307,7 +2306,7 @@ function getVariableDocStringNode(node) {
         return undefined;
     }
     // A docstring can consist of multiple joined strings in a single expression.
-    return nextStatement.statements[0];
+    return nextStatement.d.statements[0];
 }
 exports.getVariableDocStringNode = getVariableDocStringNode;
 // Creates an ID that identifies this parse node in a way that will
@@ -2316,10 +2315,10 @@ exports.getVariableDocStringNode = getVariableDocStringNode;
 function getScopeIdForNode(node) {
     let name = '';
     if (node.nodeType === 10 /* ParseNodeType.Class */) {
-        name = node.name.value;
+        name = node.d.name.d.value;
     }
     else if (node.nodeType === 31 /* ParseNodeType.Function */) {
-        name = node.name.value;
+        name = node.d.name.d.value;
     }
     const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
     return `${fileInfo.fileUri.key}.${node.start.toString()}-${name}`;
@@ -2342,7 +2341,7 @@ function getTypeVarScopesForNode(node) {
 }
 exports.getTypeVarScopesForNode = getTypeVarScopesForNode;
 function checkDecorator(node, value) {
-    return node.expression.nodeType === 38 /* ParseNodeType.Name */ && node.expression.value === value;
+    return node.d.expr.nodeType === 38 /* ParseNodeType.Name */ && node.d.expr.d.value === value;
 }
 exports.checkDecorator = checkDecorator;
 function isSimpleDefault(node) {
@@ -2352,13 +2351,13 @@ function isSimpleDefault(node) {
         case 35 /* ParseNodeType.MemberAccess */:
             return true;
         case 49 /* ParseNodeType.String */:
-            return (node.token.flags & 64 /* StringTokenFlags.Format */) === 0;
+            return (node.d.token.flags & 64 /* StringTokenFlags.Format */) === 0;
         case 48 /* ParseNodeType.StringList */:
-            return node.strings.every(isSimpleDefault);
+            return node.d.strings.every(isSimpleDefault);
         case 55 /* ParseNodeType.UnaryOperation */:
-            return isSimpleDefault(node.expression);
+            return isSimpleDefault(node.d.expr);
         case 7 /* ParseNodeType.BinaryOperation */:
-            return isSimpleDefault(node.leftExpression) && isSimpleDefault(node.rightExpression);
+            return isSimpleDefault(node.d.leftExpr) && isSimpleDefault(node.d.rightExpr);
         default:
             return false;
     }