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

package/dist/analyzer/binder.js

@@ -128,14 +128,10 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             this._addImplicitSymbolToCurrentScope('__dict__', node, 'Dict[str, Any]');
             this._addImplicitSymbolToCurrentScope('__annotations__', node, 'Dict[str, Any]');
             this._addImplicitSymbolToCurrentScope('__builtins__', node, 'Any');
-            // If there is a static docstring provided in the module, assume
-            // that the type of `__doc__` is `str` rather than `str | None`. This
-            // doesn't apply to stub files.
-            const moduleDocString = ParseTreeUtils.getDocString(node.statements);
-            this._addImplicitSymbolToCurrentScope('__doc__', node, !this._fileInfo.isStubFile && moduleDocString ? 'str' : 'str | None');
+            this._addImplicitSymbolToCurrentScope('__doc__', node, 'str | None');
             // Create a start node for the module.
             this._currentFlowNode = this._createStartFlowNode();
-            this._walkStatementsAndReportUnreachable(node.statements);
+            this._walkStatementsAndReportUnreachable(node.d.statements);
             // Associate the code flow node at the end of the module with the module.
             AnalyzerNodeInfo.setAfterFlowNode(node, this._currentFlowNode);
             AnalyzerNodeInfo.setCodeFlowExpressions(node, this._currentScopeCodeFlowExpressions);
@@ -187,7 +183,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         return false;
     }
     visitSuite(node) {
-        this._walkStatementsAndReportUnreachable(node.statements);
+        this._walkStatementsAndReportUnreachable(node.d.statements);
         return false;
     }
     visitModuleName(node) {
@@ -220,27 +216,27 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitClass(node) {
-        this.walkMultiple(node.decorators);
+        this.walkMultiple(node.d.decorators);
         const classDeclaration = {
             type: 6 /* DeclarationType.Class */,
             node,
             uri: this._fileInfo.fileUri,
-            range: (0, positionUtils_1.convertTextRangeToRange)(node.name, this._fileInfo.lines),
+            range: (0, positionUtils_1.convertTextRangeToRange)(node.d.name, this._fileInfo.lines),
             moduleName: this._fileInfo.moduleName,
             isInExceptSuite: this._isInExceptSuite,
         };
-        const symbol = this._bindNameToScope(this._currentScope, node.name);
+        const symbol = this._bindNameToScope(this._currentScope, node.d.name);
         if (symbol) {
             symbol.addDeclaration(classDeclaration);
         }
         // Stash the declaration in the parse node for later access.
         AnalyzerNodeInfo.setDeclaration(node, classDeclaration);
         let typeParamScope;
-        if (node.typeParameters) {
-            this.walk(node.typeParameters);
-            typeParamScope = AnalyzerNodeInfo.getScope(node.typeParameters);
+        if (node.d.typeParams) {
+            this.walk(node.d.typeParams);
+            typeParamScope = AnalyzerNodeInfo.getScope(node.d.typeParams);
         }
-        this.walkMultiple(node.arguments);
+        this.walkMultiple(node.d.arguments);
         this._createNewScope(3 /* ScopeType.Class */, typeParamScope !== null && typeParamScope !== void 0 ? typeParamScope : this._getNonClassParentScope(), 
         /* proxyScope */ undefined, () => {
             AnalyzerNodeInfo.setScope(node, this._currentScope);
@@ -250,20 +246,20 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             this._dunderSlotsEntries = undefined;
             if (!this._moduleSymbolOnly) {
                 // Analyze the suite.
-                this.walk(node.suite);
+                this.walk(node.d.suite);
             }
             if (this._dunderSlotsEntries) {
                 this._addSlotsToCurrentScope(this._dunderSlotsEntries);
             }
             this._dunderSlotsEntries = undefined;
         });
-        this._createAssignmentTargetFlowNodes(node.name, /* walkTargets */ false, /* unbound */ false);
+        this._createAssignmentTargetFlowNodes(node.d.name, /* walkTargets */ false, /* unbound */ false);
         return false;
     }
     visitFunction(node) {
         this._createVariableAnnotationFlowNode();
         AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
-        const symbol = this._bindNameToScope(this._currentScope, node.name);
+        const symbol = this._bindNameToScope(this._currentScope, node.d.name);
         const containingClassNode = ParseTreeUtils.getEnclosingClass(node, /* stopAtFunction */ true);
         const functionDeclaration = {
             type: 5 /* DeclarationType.Function */,
@@ -271,7 +267,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             isMethod: !!containingClassNode,
             isGenerator: false,
             uri: this._fileInfo.fileUri,
-            range: (0, positionUtils_1.convertTextRangeToRange)(node.name, this._fileInfo.lines),
+            range: (0, positionUtils_1.convertTextRangeToRange)(node.d.name, this._fileInfo.lines),
             moduleName: this._fileInfo.moduleName,
             isInExceptSuite: this._isInExceptSuite,
         };
@@ -281,30 +277,30 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         // Stash the declaration in the parse node for later access.
         AnalyzerNodeInfo.setDeclaration(node, functionDeclaration);
         // Walk the default values prior to the type parameters.
-        node.parameters.forEach((param) => {
-            if (param.defaultValue) {
-                this.walk(param.defaultValue);
+        node.d.params.forEach((param) => {
+            if (param.d.defaultValue) {
+                this.walk(param.d.defaultValue);
             }
         });
         let typeParamScope;
-        if (node.typeParameters) {
-            this.walk(node.typeParameters);
-            typeParamScope = AnalyzerNodeInfo.getScope(node.typeParameters);
+        if (node.d.typeParams) {
+            this.walk(node.d.typeParams);
+            typeParamScope = AnalyzerNodeInfo.getScope(node.d.typeParams);
         }
-        this.walkMultiple(node.decorators);
-        node.parameters.forEach((param) => {
-            if (param.typeAnnotation) {
-                this.walk(param.typeAnnotation);
+        this.walkMultiple(node.d.decorators);
+        node.d.params.forEach((param) => {
+            if (param.d.annotation) {
+                this.walk(param.d.annotation);
             }
-            if (param.typeAnnotationComment) {
-                this.walk(param.typeAnnotationComment);
+            if (param.d.annotationComment) {
+                this.walk(param.d.annotationComment);
             }
         });
-        if (node.returnTypeAnnotation) {
-            this.walk(node.returnTypeAnnotation);
+        if (node.d.returnAnnotation) {
+            this.walk(node.d.returnAnnotation);
         }
-        if (node.functionAnnotationComment) {
-            this.walk(node.functionAnnotationComment);
+        if (node.d.funcAnnotationComment) {
+            this.walk(node.d.funcAnnotationComment);
         }
         // Don't walk the body of the function until we're done analyzing
         // the current scope.
@@ -314,20 +310,20 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             const enclosingClass = ParseTreeUtils.getEnclosingClass(node);
             if (enclosingClass) {
                 // Add the implicit "__class__" symbol described in PEP 3135.
-                this._addImplicitSymbolToCurrentScope('__class__', node, 'class');
+                this._addImplicitSymbolToCurrentScope('__class__', node, 'type[self]');
             }
             this._deferBinding(() => {
                 // Create a start node for the function.
                 this._currentFlowNode = this._createStartFlowNode();
                 this._codeFlowComplexity = 0;
-                node.parameters.forEach((paramNode) => {
+                node.d.params.forEach((paramNode) => {
                     var _a, _b;
-                    if (paramNode.name) {
-                        const symbol = this._bindNameToScope(this._currentScope, paramNode.name);
+                    if (paramNode.d.name) {
+                        const symbol = this._bindNameToScope(this._currentScope, paramNode.d.name);
                         // Extract the parameter docString from the function docString
-                        let docString = ParseTreeUtils.getDocString((_b = (_a = node === null || node === void 0 ? void 0 : node.suite) === null || _a === void 0 ? void 0 : _a.statements) !== null && _b !== void 0 ? _b : []);
+                        let docString = ParseTreeUtils.getDocString((_b = (_a = node === null || node === void 0 ? void 0 : node.d.suite) === null || _a === void 0 ? void 0 : _a.d.statements) !== null && _b !== void 0 ? _b : []);
                         if (docString !== undefined) {
-                            docString = (0, docStringUtils_1.extractParameterDocumentation)(docString, paramNode.name.value);
+                            docString = (0, docStringUtils_1.extractParameterDocumentation)(docString, paramNode.d.name.d.value);
                         }
                         if (symbol) {
                             const paramDeclaration = {
@@ -340,19 +336,19 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                                 docString: docString,
                             };
                             symbol.addDeclaration(paramDeclaration);
-                            AnalyzerNodeInfo.setDeclaration(paramNode.name, paramDeclaration);
+                            AnalyzerNodeInfo.setDeclaration(paramNode.d.name, paramDeclaration);
                         }
-                        this._createFlowAssignment(paramNode.name);
+                        this._createFlowAssignment(paramNode.d.name);
                     }
                 });
                 this._targetFunctionDeclaration = functionDeclaration;
                 this._currentReturnTarget = this._createBranchLabel();
                 // Walk the statements that make up the function.
-                this.walk(node.suite);
+                this.walk(node.d.suite);
                 this._targetFunctionDeclaration = undefined;
                 // Associate the code flow node at the end of the suite with
                 // the suite.
-                AnalyzerNodeInfo.setAfterFlowNode(node.suite, this._currentFlowNode);
+                AnalyzerNodeInfo.setAfterFlowNode(node.d.suite, this._currentFlowNode);
                 // Compute the final return flow node and associate it with
                 // the function's parse node. If this node is unreachable, then
                 // the function never returns.
@@ -363,7 +359,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 AnalyzerNodeInfo.setCodeFlowComplexity(node, this._codeFlowComplexity);
             });
         });
-        this._createAssignmentTargetFlowNodes(node.name, /* walkTargets */ false, /* unbound */ false);
+        this._createAssignmentTargetFlowNodes(node.d.name, /* walkTargets */ false, /* unbound */ false);
         // We'll walk the child nodes in a deferred manner, so don't walk them now.
         return false;
     }
@@ -372,9 +368,9 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
         // Analyze the parameter defaults in the context of the parent's scope
         // before we add any names from the function's scope.
-        node.parameters.forEach((param) => {
-            if (param.defaultValue) {
-                this.walk(param.defaultValue);
+        node.d.params.forEach((param) => {
+            if (param.d.defaultValue) {
+                this.walk(param.d.defaultValue);
             }
         });
         this._createNewScope(2 /* ScopeType.Function */, this._getNonClassParentScope(), /* proxyScope */ undefined, () => {
@@ -382,9 +378,9 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             this._deferBinding(() => {
                 // Create a start node for the lambda.
                 this._currentFlowNode = this._createStartFlowNode();
-                node.parameters.forEach((paramNode) => {
-                    if (paramNode.name) {
-                        const symbol = this._bindNameToScope(this._currentScope, paramNode.name);
+                node.d.params.forEach((paramNode) => {
+                    if (paramNode.d.name) {
+                        const symbol = this._bindNameToScope(this._currentScope, paramNode.d.name);
                         if (symbol) {
                             const paramDeclaration = {
                                 type: 2 /* DeclarationType.Parameter */,
@@ -395,15 +391,15 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                                 isInExceptSuite: this._isInExceptSuite,
                             };
                             symbol.addDeclaration(paramDeclaration);
-                            AnalyzerNodeInfo.setDeclaration(paramNode.name, paramDeclaration);
+                            AnalyzerNodeInfo.setDeclaration(paramNode.d.name, paramDeclaration);
                         }
-                        this._createFlowAssignment(paramNode.name);
-                        this.walk(paramNode.name);
+                        this._createFlowAssignment(paramNode.d.name);
+                        this.walk(paramNode.d.name);
                         AnalyzerNodeInfo.setFlowNode(paramNode, this._currentFlowNode);
                     }
                 });
                 // Walk the expression that make up the lambda body.
-                this.walk(node.expression);
+                this.walk(node.d.expr);
                 AnalyzerNodeInfo.setCodeFlowExpressions(node, this._currentScopeCodeFlowExpressions);
             });
         });
@@ -413,7 +409,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     visitCall(node) {
         var _a, _b;
         this._disableTrueFalseTargets(() => {
-            this.walk(node.leftExpression);
+            this.walk(node.d.leftExpr);
             const sortedArgs = ParseTreeUtils.getArgumentsByRuntimeOrder(node);
             sortedArgs.forEach((argNode) => {
                 if (this._currentFlowNode) {
@@ -437,31 +433,31 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         }
         // Is this an manipulation of dunder all?
         if (this._currentScope.type === 4 /* ScopeType.Module */ &&
-            node.leftExpression.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
-            node.leftExpression.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
-            node.leftExpression.leftExpression.value === '__all__') {
+            node.d.leftExpr.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
+            node.d.leftExpr.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ &&
+            node.d.leftExpr.d.leftExpr.d.value === '__all__') {
             let emitDunderAllWarning = true;
             // Is this a call to "__all__.extend()"?
-            if (node.leftExpression.memberName.value === 'extend' && node.arguments.length === 1) {
-                const argExpr = node.arguments[0].valueExpression;
+            if (node.d.leftExpr.d.member.d.value === 'extend' && node.d.args.length === 1) {
+                const argExpr = node.d.args[0].d.valueExpr;
                 // Is this a call to "__all__.extend([<list>])"?
                 if (argExpr.nodeType === 34 /* ParseNodeType.List */) {
-                    argExpr.entries.forEach((listEntryNode) => {
+                    argExpr.d.items.forEach((listEntryNode) => {
                         var _a, _b;
                         if (listEntryNode.nodeType === 48 /* ParseNodeType.StringList */ &&
-                            listEntryNode.strings.length === 1 &&
-                            listEntryNode.strings[0].nodeType === 49 /* ParseNodeType.String */) {
-                            (_a = this._dunderAllNames) === null || _a === void 0 ? void 0 : _a.push(listEntryNode.strings[0].value);
-                            (_b = this._dunderAllStringNodes) === null || _b === void 0 ? void 0 : _b.push(listEntryNode.strings[0]);
+                            listEntryNode.d.strings.length === 1 &&
+                            listEntryNode.d.strings[0].nodeType === 49 /* ParseNodeType.String */) {
+                            (_a = this._dunderAllNames) === null || _a === void 0 ? void 0 : _a.push(listEntryNode.d.strings[0].d.value);
+                            (_b = this._dunderAllStringNodes) === null || _b === void 0 ? void 0 : _b.push(listEntryNode.d.strings[0]);
                             emitDunderAllWarning = false;
                         }
                     });
                 }
                 else if (argExpr.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
-                    argExpr.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
-                    argExpr.memberName.value === '__all__') {
+                    argExpr.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ &&
+                    argExpr.d.member.d.value === '__all__') {
                     // Is this a call to "__all__.extend(<mod>.__all__)"?
-                    const namesToAdd = this._getDunderAllNamesFromImport(argExpr.leftExpression.value);
+                    const namesToAdd = this._getDunderAllNamesFromImport(argExpr.d.leftExpr.d.value);
                     if (namesToAdd && namesToAdd.length > 0) {
                         namesToAdd.forEach((name) => {
                             var _a;
@@ -471,26 +467,26 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                     }
                 }
             }
-            else if (node.leftExpression.memberName.value === 'remove' && node.arguments.length === 1) {
+            else if (node.d.leftExpr.d.member.d.value === 'remove' && node.d.args.length === 1) {
                 // Is this a call to "__all__.remove()"?
-                const argExpr = node.arguments[0].valueExpression;
+                const argExpr = node.d.args[0].d.valueExpr;
                 if (argExpr.nodeType === 48 /* ParseNodeType.StringList */ &&
-                    argExpr.strings.length === 1 &&
-                    argExpr.strings[0].nodeType === 49 /* ParseNodeType.String */ &&
+                    argExpr.d.strings.length === 1 &&
+                    argExpr.d.strings[0].nodeType === 49 /* ParseNodeType.String */ &&
                     this._dunderAllNames) {
-                    this._dunderAllNames = this._dunderAllNames.filter((name) => name !== argExpr.strings[0].value);
-                    this._dunderAllStringNodes = this._dunderAllStringNodes.filter((node) => node.value !== argExpr.strings[0].value);
+                    this._dunderAllNames = this._dunderAllNames.filter((name) => name !== argExpr.d.strings[0].d.value);
+                    this._dunderAllStringNodes = this._dunderAllStringNodes.filter((node) => node.d.value !== argExpr.d.strings[0].d.value);
                     emitDunderAllWarning = false;
                 }
             }
-            else if (node.leftExpression.memberName.value === 'append' && node.arguments.length === 1) {
+            else if (node.d.leftExpr.d.member.d.value === 'append' && node.d.args.length === 1) {
                 // Is this a call to "__all__.append()"?
-                const argExpr = node.arguments[0].valueExpression;
+                const argExpr = node.d.args[0].d.valueExpr;
                 if (argExpr.nodeType === 48 /* ParseNodeType.StringList */ &&
-                    argExpr.strings.length === 1 &&
-                    argExpr.strings[0].nodeType === 49 /* ParseNodeType.String */) {
-                    (_a = this._dunderAllNames) === null || _a === void 0 ? void 0 : _a.push(argExpr.strings[0].value);
-                    (_b = this._dunderAllStringNodes) === null || _b === void 0 ? void 0 : _b.push(argExpr.strings[0]);
+                    argExpr.d.strings.length === 1 &&
+                    argExpr.d.strings[0].nodeType === 49 /* ParseNodeType.String */) {
+                    (_a = this._dunderAllNames) === null || _a === void 0 ? void 0 : _a.push(argExpr.d.strings[0].d.value);
+                    (_b = this._dunderAllStringNodes) === null || _b === void 0 ? void 0 : _b.push(argExpr.d.strings[0]);
                     emitDunderAllWarning = false;
                 }
             }
@@ -503,15 +499,15 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitTypeParameterList(node) {
         const typeParamScope = new scope_1.Scope(0 /* ScopeType.TypeParameter */, this._getNonClassParentScope(), this._currentScope);
-        node.parameters.forEach((param) => {
-            if (param.boundExpression) {
-                this.walk(param.boundExpression);
+        node.d.params.forEach((param) => {
+            if (param.d.boundExpr) {
+                this.walk(param.d.boundExpr);
             }
         });
         const typeParamsSeen = new Set();
-        node.parameters.forEach((param) => {
-            const name = param.name;
-            const symbol = typeParamScope.addSymbol(name.value, 0 /* SymbolFlags.None */);
+        node.d.params.forEach((param) => {
+            const name = param.d.name;
+            const symbol = typeParamScope.addSymbol(name.d.value, 0 /* SymbolFlags.None */);
             const paramDeclaration = {
                 type: 3 /* DeclarationType.TypeParameter */,
                 node: param,
@@ -522,48 +518,48 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             };
             symbol.addDeclaration(paramDeclaration);
             AnalyzerNodeInfo.setDeclaration(name, paramDeclaration);
-            if (typeParamsSeen.has(name.value)) {
-                this._addSyntaxError(localize_1.LocMessage.typeParameterExistingTypeParameter().format({ name: name.value }), name);
+            if (typeParamsSeen.has(name.d.value)) {
+                this._addSyntaxError(localize_1.LocMessage.typeParameterExistingTypeParameter().format({ name: name.d.value }), name);
             }
             else {
-                typeParamsSeen.add(name.value);
+                typeParamsSeen.add(name.d.value);
             }
         });
-        node.parameters.forEach((param) => {
-            if (param.defaultExpression) {
-                this.walk(param.defaultExpression);
+        node.d.params.forEach((param) => {
+            if (param.d.defaultExpr) {
+                this.walk(param.d.defaultExpr);
             }
         });
         AnalyzerNodeInfo.setScope(node, typeParamScope);
         return false;
     }
     visitTypeAlias(node) {
-        this._bindNameToScope(this._currentScope, node.name);
-        this.walk(node.name);
+        this._bindNameToScope(this._currentScope, node.d.name);
+        this.walk(node.d.name);
         let typeParamScope;
-        if (node.typeParameters) {
-            this.walk(node.typeParameters);
-            typeParamScope = AnalyzerNodeInfo.getScope(node.typeParameters);
+        if (node.d.typeParams) {
+            this.walk(node.d.typeParams);
+            typeParamScope = AnalyzerNodeInfo.getScope(node.d.typeParams);
         }
         const typeAliasDeclaration = {
             type: 4 /* DeclarationType.TypeAlias */,
             node,
             uri: this._fileInfo.fileUri,
-            range: (0, positionUtils_1.convertTextRangeToRange)(node.name, this._fileInfo.lines),
+            range: (0, positionUtils_1.convertTextRangeToRange)(node.d.name, this._fileInfo.lines),
             moduleName: this._fileInfo.moduleName,
             isInExceptSuite: this._isInExceptSuite,
-            docString: this._getVariableDocString(node.expression),
+            docString: this._getVariableDocString(node.d.expr),
         };
-        const symbol = this._bindNameToScope(this._currentScope, node.name);
+        const symbol = this._bindNameToScope(this._currentScope, node.d.name);
         if (symbol) {
             symbol.addDeclaration(typeAliasDeclaration);
         }
         // Stash the declaration in the parse node for later access.
         AnalyzerNodeInfo.setDeclaration(node, typeAliasDeclaration);
-        this._createAssignmentTargetFlowNodes(node.name, /* walkTargets */ true, /* unbound */ false);
+        this._createAssignmentTargetFlowNodes(node.d.name, /* walkTargets */ true, /* unbound */ false);
         const prevScope = this._currentScope;
         this._currentScope = typeParamScope !== null && typeParamScope !== void 0 ? typeParamScope : this._currentScope;
-        this.walk(node.expression);
+        this.walk(node.d.expr);
         this._currentScope = prevScope;
         return false;
     }
@@ -571,36 +567,36 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         if (this._handleTypingStubAssignmentOrAnnotation(node)) {
             return false;
         }
-        this._bindPossibleTupleNamedTarget(node.leftExpression);
-        if (node.typeAnnotationComment) {
-            this.walk(node.typeAnnotationComment);
-            this._addTypeDeclarationForVariable(node.leftExpression, node.typeAnnotationComment);
+        this._bindPossibleTupleNamedTarget(node.d.leftExpr);
+        if (node.d.annotationComment) {
+            this.walk(node.d.annotationComment);
+            this._addTypeDeclarationForVariable(node.d.leftExpr, node.d.annotationComment);
         }
-        if (node.chainedTypeAnnotationComment) {
-            this._addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.annotationNotSupported(), node.chainedTypeAnnotationComment);
+        if (node.d.chainedAnnotationComment) {
+            this._addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.annotationNotSupported(), node.d.chainedAnnotationComment);
         }
         // If the assignment target base expression is potentially a
         // TypedDict, add the base expression to the flow expressions set
         // to accommodate TypedDict type narrowing.
-        if (node.leftExpression.nodeType === 27 /* ParseNodeType.Index */) {
-            const target = node.leftExpression;
-            if (target.items.length === 1 &&
-                !target.trailingComma &&
-                target.items[0].valueExpression.nodeType === 48 /* ParseNodeType.StringList */) {
-                if ((0, codeFlowTypes_1.isCodeFlowSupportedForReference)(target.baseExpression)) {
-                    const baseExprReferenceKey = (0, codeFlowTypes_1.createKeyForReference)(target.baseExpression);
+        if (node.d.leftExpr.nodeType === 27 /* ParseNodeType.Index */) {
+            const target = node.d.leftExpr;
+            if (target.d.items.length === 1 &&
+                !target.d.trailingComma &&
+                target.d.items[0].d.valueExpr.nodeType === 48 /* ParseNodeType.StringList */) {
+                if ((0, codeFlowTypes_1.isCodeFlowSupportedForReference)(target.d.leftExpr)) {
+                    const baseExprReferenceKey = (0, codeFlowTypes_1.createKeyForReference)(target.d.leftExpr);
                     this._currentScopeCodeFlowExpressions.add(baseExprReferenceKey);
                 }
             }
         }
-        this.walk(node.rightExpression);
+        this.walk(node.d.rightExpr);
         let isPossibleTypeAlias = true;
         if (ParseTreeUtils.getEnclosingFunction(node)) {
             // We will assume that type aliases are defined only at the module level
             // or as class variables, not as local variables within a function.
             isPossibleTypeAlias = false;
         }
-        else if (node.rightExpression.nodeType === 9 /* ParseNodeType.Call */ && this._fileInfo.isTypingStubFile) {
+        else if (node.d.rightExpr.nodeType === 9 /* ParseNodeType.Call */ && this._fileInfo.isTypingStubFile) {
             // Some special built-in types defined in typing.pyi use
             // assignments of the form List = _Alias(). We don't want to
             // treat these as type aliases.
@@ -610,25 +606,25 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             // Assume that it's not a type alias if it's within a loop.
             isPossibleTypeAlias = false;
         }
-        this._addInferredTypeAssignmentForVariable(node.leftExpression, node.rightExpression, isPossibleTypeAlias);
+        this._addInferredTypeAssignmentForVariable(node.d.leftExpr, node.d.rightExpr, isPossibleTypeAlias);
         // If we didn't create assignment target flow nodes above, do so now.
-        this._createAssignmentTargetFlowNodes(node.leftExpression, /* walkTargets */ true, /* unbound */ false);
+        this._createAssignmentTargetFlowNodes(node.d.leftExpr, /* walkTargets */ true, /* unbound */ false);
         // Is this an assignment to dunder all?
         if (this._currentScope.type === 4 /* ScopeType.Module */) {
-            if ((node.leftExpression.nodeType === 38 /* ParseNodeType.Name */ && node.leftExpression.value === '__all__') ||
-                (node.leftExpression.nodeType === 54 /* ParseNodeType.TypeAnnotation */ &&
-                    node.leftExpression.valueExpression.nodeType === 38 /* ParseNodeType.Name */ &&
-                    node.leftExpression.valueExpression.value === '__all__')) {
-                const expr = node.rightExpression;
+            if ((node.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ && node.d.leftExpr.d.value === '__all__') ||
+                (node.d.leftExpr.nodeType === 54 /* ParseNodeType.TypeAnnotation */ &&
+                    node.d.leftExpr.d.valueExpr.nodeType === 38 /* ParseNodeType.Name */ &&
+                    node.d.leftExpr.d.valueExpr.d.value === '__all__')) {
+                const expr = node.d.rightExpr;
                 this._dunderAllNames = [];
                 let emitDunderAllWarning = false;
                 if (expr.nodeType === 34 /* ParseNodeType.List */) {
-                    expr.entries.forEach((listEntryNode) => {
+                    expr.d.items.forEach((listEntryNode) => {
                         if (listEntryNode.nodeType === 48 /* ParseNodeType.StringList */ &&
-                            listEntryNode.strings.length === 1 &&
-                            listEntryNode.strings[0].nodeType === 49 /* ParseNodeType.String */) {
-                            this._dunderAllNames.push(listEntryNode.strings[0].value);
-                            this._dunderAllStringNodes.push(listEntryNode.strings[0]);
+                            listEntryNode.d.strings.length === 1 &&
+                            listEntryNode.d.strings[0].nodeType === 49 /* ParseNodeType.String */) {
+                            this._dunderAllNames.push(listEntryNode.d.strings[0].d.value);
+                            this._dunderAllStringNodes.push(listEntryNode.d.strings[0]);
                         }
                         else {
                             emitDunderAllWarning = true;
@@ -636,12 +632,12 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                     });
                 }
                 else if (expr.nodeType === 52 /* ParseNodeType.Tuple */) {
-                    expr.expressions.forEach((tupleEntryNode) => {
+                    expr.d.items.forEach((tupleEntryNode) => {
                         if (tupleEntryNode.nodeType === 48 /* ParseNodeType.StringList */ &&
-                            tupleEntryNode.strings.length === 1 &&
-                            tupleEntryNode.strings[0].nodeType === 49 /* ParseNodeType.String */) {
-                            this._dunderAllNames.push(tupleEntryNode.strings[0].value);
-                            this._dunderAllStringNodes.push(tupleEntryNode.strings[0]);
+                            tupleEntryNode.d.strings.length === 1 &&
+                            tupleEntryNode.d.strings[0].nodeType === 49 /* ParseNodeType.String */) {
+                            this._dunderAllNames.push(tupleEntryNode.d.strings[0].d.value);
+                            this._dunderAllStringNodes.push(tupleEntryNode.d.strings[0]);
                         }
                         else {
                             emitDunderAllWarning = true;
@@ -659,21 +655,21 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         }
         // Is this an assignment to dunder slots?
         if (this._currentScope.type === 3 /* ScopeType.Class */) {
-            if ((node.leftExpression.nodeType === 38 /* ParseNodeType.Name */ && node.leftExpression.value === '__slots__') ||
-                (node.leftExpression.nodeType === 54 /* ParseNodeType.TypeAnnotation */ &&
-                    node.leftExpression.valueExpression.nodeType === 38 /* ParseNodeType.Name */ &&
-                    node.leftExpression.valueExpression.value === '__slots__')) {
-                const expr = node.rightExpression;
+            if ((node.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ && node.d.leftExpr.d.value === '__slots__') ||
+                (node.d.leftExpr.nodeType === 54 /* ParseNodeType.TypeAnnotation */ &&
+                    node.d.leftExpr.d.valueExpr.nodeType === 38 /* ParseNodeType.Name */ &&
+                    node.d.leftExpr.d.valueExpr.d.value === '__slots__')) {
+                const expr = node.d.rightExpr;
                 this._dunderSlotsEntries = [];
                 let isExpressionUnderstood = true;
                 if (expr.nodeType === 48 /* ParseNodeType.StringList */) {
                     this._dunderSlotsEntries.push(expr);
                 }
                 else if (expr.nodeType === 34 /* ParseNodeType.List */) {
-                    expr.entries.forEach((listEntryNode) => {
+                    expr.d.items.forEach((listEntryNode) => {
                         if (listEntryNode.nodeType === 48 /* ParseNodeType.StringList */ &&
-                            listEntryNode.strings.length === 1 &&
-                            listEntryNode.strings[0].nodeType === 49 /* ParseNodeType.String */) {
+                            listEntryNode.d.strings.length === 1 &&
+                            listEntryNode.d.strings[0].nodeType === 49 /* ParseNodeType.String */) {
                             this._dunderSlotsEntries.push(listEntryNode);
                         }
                         else {
@@ -682,10 +678,10 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                     });
                 }
                 else if (expr.nodeType === 52 /* ParseNodeType.Tuple */) {
-                    expr.expressions.forEach((tupleEntryNode) => {
+                    expr.d.items.forEach((tupleEntryNode) => {
                         if (tupleEntryNode.nodeType === 48 /* ParseNodeType.StringList */ &&
-                            tupleEntryNode.strings.length === 1 &&
-                            tupleEntryNode.strings[0].nodeType === 49 /* ParseNodeType.String */) {
+                            tupleEntryNode.d.strings.length === 1 &&
+                            tupleEntryNode.d.strings[0].nodeType === 49 /* ParseNodeType.String */) {
                             this._dunderSlotsEntries.push(tupleEntryNode);
                         }
                         else {
@@ -708,12 +704,12 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         // expression is located within an if/else conditional.
         this._disableTrueFalseTargets(() => {
             // Evaluate the operand expression.
-            this.walk(node.rightExpression);
+            this.walk(node.d.rightExpr);
         });
         const evaluationNode = ParseTreeUtils.getEvaluationNodeForAssignmentExpression(node);
         if (!evaluationNode) {
             this._addSyntaxError(localize_1.LocMessage.assignmentExprContext(), node);
-            this.walk(node.name);
+            this.walk(node.d.name);
         }
         else {
             // Bind the name to the containing scope. This special logic is required
@@ -726,50 +722,50 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             // expression.
             let curScope = this._currentScope;
             while (curScope && curScope !== containerScope) {
-                const localSymbol = curScope.lookUpSymbol(node.name.value);
+                const localSymbol = curScope.lookUpSymbol(node.d.name.d.value);
                 if (localSymbol) {
-                    this._addSyntaxError(localize_1.LocMessage.assignmentExprComprehension().format({ name: node.name.value }), node.name);
+                    this._addSyntaxError(localize_1.LocMessage.assignmentExprComprehension().format({ name: node.d.name.d.value }), node.d.name);
                     break;
                 }
                 curScope = curScope.parent;
             }
-            this._bindNameToScope(containerScope, node.name);
-            this._addInferredTypeAssignmentForVariable(node.name, node.rightExpression);
-            this._createAssignmentTargetFlowNodes(node.name, /* walkTargets */ true, /* unbound */ false);
+            this._bindNameToScope(containerScope, node.d.name);
+            this._addInferredTypeAssignmentForVariable(node.d.name, node.d.rightExpr);
+            this._createAssignmentTargetFlowNodes(node.d.name, /* walkTargets */ true, /* unbound */ false);
         }
         return false;
     }
     visitAugmentedAssignment(node) {
-        this.walk(node.leftExpression);
-        this.walk(node.rightExpression);
-        this._bindPossibleTupleNamedTarget(node.destExpression);
-        this._createAssignmentTargetFlowNodes(node.destExpression, /* walkTargets */ false, /* unbound */ false);
+        this.walk(node.d.leftExpr);
+        this.walk(node.d.rightExpr);
+        this._bindPossibleTupleNamedTarget(node.d.destExpr);
+        this._createAssignmentTargetFlowNodes(node.d.destExpr, /* walkTargets */ false, /* unbound */ false);
         // Is this an assignment to dunder all of the form
         // __all__ += <expression>?
-        if (node.operator === 1 /* OperatorType.AddEqual */ &&
+        if (node.d.operator === 1 /* OperatorType.AddEqual */ &&
             this._currentScope.type === 4 /* ScopeType.Module */ &&
-            node.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
-            node.leftExpression.value === '__all__') {
-            const expr = node.rightExpression;
+            node.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ &&
+            node.d.leftExpr.d.value === '__all__') {
+            const expr = node.d.rightExpr;
             let emitDunderAllWarning = true;
             if (expr.nodeType === 34 /* ParseNodeType.List */) {
                 // Is this the form __all__ += ["a", "b"]?
-                expr.entries.forEach((listEntryNode) => {
+                expr.d.items.forEach((listEntryNode) => {
                     var _a;
                     if (listEntryNode.nodeType === 48 /* ParseNodeType.StringList */ &&
-                        listEntryNode.strings.length === 1 &&
-                        listEntryNode.strings[0].nodeType === 49 /* ParseNodeType.String */) {
-                        (_a = this._dunderAllNames) === null || _a === void 0 ? void 0 : _a.push(listEntryNode.strings[0].value);
-                        this._dunderAllStringNodes.push(listEntryNode.strings[0]);
+                        listEntryNode.d.strings.length === 1 &&
+                        listEntryNode.d.strings[0].nodeType === 49 /* ParseNodeType.String */) {
+                        (_a = this._dunderAllNames) === null || _a === void 0 ? void 0 : _a.push(listEntryNode.d.strings[0].d.value);
+                        this._dunderAllStringNodes.push(listEntryNode.d.strings[0]);
                     }
                 });
                 emitDunderAllWarning = false;
             }
             else if (expr.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
-                expr.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
-                expr.memberName.value === '__all__') {
+                expr.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ &&
+                expr.d.member.d.value === '__all__') {
                 // Is this using the form "__all__ += <mod>.__all__"?
-                const namesToAdd = this._getDunderAllNamesFromImport(expr.leftExpression.value);
+                const namesToAdd = this._getDunderAllNamesFromImport(expr.d.leftExpr.d.value);
                 if (namesToAdd) {
                     namesToAdd.forEach((name) => {
                         var _a;
@@ -786,7 +782,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         return false;
     }
     visitDel(node) {
-        node.expressions.forEach((expr) => {
+        node.d.targets.forEach((expr) => {
             this._bindPossibleTupleNamedTarget(expr);
             this.walk(expr);
             this._createAssignmentTargetFlowNodes(expr, /* walkTargets */ false, /* unbound */ true);
@@ -803,32 +799,32 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         const bindVariableBeforeAnnotationEvaluation = ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 3 /* ParseNodeType.Assignment */ &&
             ParseTreeUtils.getEnclosingClass(node, /* stopAtFunction */ true) !== undefined;
         if (!bindVariableBeforeAnnotationEvaluation) {
-            this.walk(node.typeAnnotation);
+            this.walk(node.d.annotation);
         }
         this._createVariableAnnotationFlowNode();
-        this._bindPossibleTupleNamedTarget(node.valueExpression);
-        this._addTypeDeclarationForVariable(node.valueExpression, node.typeAnnotation);
+        this._bindPossibleTupleNamedTarget(node.d.valueExpr);
+        this._addTypeDeclarationForVariable(node.d.valueExpr, node.d.annotation);
         if (bindVariableBeforeAnnotationEvaluation) {
-            this.walk(node.typeAnnotation);
+            this.walk(node.d.annotation);
         }
         // For type annotations that are not part of assignments (e.g. simple variable
         // annotations), we need to populate the reference map. Otherwise the type
         // analyzer's code flow engine won't run and detect cases where the variable
         // is unbound.
         const expressionList = [];
-        if (this._isNarrowingExpression(node.valueExpression, expressionList)) {
+        if (this._isNarrowingExpression(node.d.valueExpr, expressionList)) {
             expressionList.forEach((expr) => {
                 const referenceKey = (0, codeFlowTypes_1.createKeyForReference)(expr);
                 this._currentScopeCodeFlowExpressions.add(referenceKey);
             });
         }
-        this.walk(node.valueExpression);
+        this.walk(node.d.valueExpr);
         return false;
     }
     visitFor(node) {
-        this._bindPossibleTupleNamedTarget(node.targetExpression);
-        this._addInferredTypeAssignmentForVariable(node.targetExpression, node);
-        this.walk(node.iterableExpression);
+        this._bindPossibleTupleNamedTarget(node.d.targetExpr);
+        this._addInferredTypeAssignmentForVariable(node.d.targetExpr, node);
+        this.walk(node.d.iterableExpr);
         const preForLabel = this._createLoopLabel();
         const preElseLabel = this._createBranchLabel();
         const postForLabel = this._createBranchLabel();
@@ -836,10 +832,10 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         this._currentFlowNode = preForLabel;
         this._addAntecedent(preElseLabel, this._currentFlowNode);
         const targetExpressions = this._trackCodeFlowExpressions(() => {
-            this._createAssignmentTargetFlowNodes(node.targetExpression, /* walkTargets */ true, /* unbound */ false);
+            this._createAssignmentTargetFlowNodes(node.d.targetExpr, /* walkTargets */ true, /* unbound */ false);
         });
         this._bindLoopStatement(preForLabel, postForLabel, () => {
-            this.walk(node.forSuite);
+            this.walk(node.d.forSuite);
             this._addAntecedent(preForLabel, this._currentFlowNode);
             // Add any target expressions since they are modified in the loop.
             targetExpressions.forEach((value) => {
@@ -848,17 +844,17 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             });
         });
         this._currentFlowNode = this._finishFlowLabel(preElseLabel);
-        if (node.elseSuite) {
-            this.walk(node.elseSuite);
+        if (node.d.elseSuite) {
+            this.walk(node.d.elseSuite);
         }
         this._addAntecedent(postForLabel, this._currentFlowNode);
         this._currentFlowNode = this._finishFlowLabel(postForLabel);
         // Async for is not allowed outside of an async function
         // unless we're in ipython mode.
-        if (node.asyncToken && !this._fileInfo.ipythonMode) {
+        if (node.d.asyncToken && !this._fileInfo.ipythonMode) {
             const enclosingFunction = ParseTreeUtils.getEnclosingFunction(node);
-            if (!enclosingFunction || !enclosingFunction.isAsync) {
-                this._addSyntaxError(localize_1.LocMessage.asyncNotInAsyncFunction(), node.asyncToken);
+            if (!enclosingFunction || !enclosingFunction.d.isAsync) {
+                this._addSyntaxError(localize_1.LocMessage.asyncNotInAsyncFunction(), node.d.asyncToken);
             }
         }
         return false;
@@ -886,8 +882,8 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             }
             this._targetFunctionDeclaration.returnStatements.push(node);
         }
-        if (node.returnExpression) {
-            this.walk(node.returnExpression);
+        if (node.d.expr) {
+            this.walk(node.d.expr);
         }
         AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
         if (this._currentReturnTarget) {
@@ -914,7 +910,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         return false;
     }
     visitMemberAccess(node) {
-        this.walk(node.leftExpression);
+        this.walk(node.d.leftExpr);
         AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
         return false;
     }
@@ -924,13 +920,13 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitIndex(node) {
         AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
-        this.walk(node.baseExpression);
+        this.walk(node.d.leftExpr);
         // If we're within an 'Annotated' type annotation, set the flag.
         const wasInAnnotatedAnnotation = this._isInAnnotatedAnnotation;
-        if (this._isTypingAnnotation(node.baseExpression, 'Annotated')) {
+        if (this._isTypingAnnotation(node.d.leftExpr, 'Annotated')) {
             this._isInAnnotatedAnnotation = true;
         }
-        node.items.forEach((argNode) => {
+        node.d.items.forEach((argNode) => {
             this.walk(argNode);
         });
         this._isInAnnotatedAnnotation = wasInAnnotatedAnnotation;
@@ -944,23 +940,23 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         postIfLabel.affectedExpressions = this._trackCodeFlowExpressions(() => {
             // Determine if the test condition is always true or always false. If so,
             // we can treat either the then or the else clause as unconditional.
-            const constExprValue = StaticExpressions.evaluateStaticBoolLikeExpression(node.testExpression, this._fileInfo.executionEnvironment, this._fileInfo.definedConstants, this._typingImportAliases, this._sysImportAliases);
-            this._bindConditional(node.testExpression, thenLabel, elseLabel);
+            const constExprValue = StaticExpressions.evaluateStaticBoolLikeExpression(node.d.testExpr, this._fileInfo.executionEnvironment, this._fileInfo.definedConstants, this._typingImportAliases, this._sysImportAliases);
+            this._bindConditional(node.d.testExpr, thenLabel, elseLabel);
             // Handle the if clause.
             this._currentFlowNode =
                 constExprValue === false ? Binder._unreachableFlowNode : this._finishFlowLabel(thenLabel);
-            this.walk(node.ifSuite);
+            this.walk(node.d.ifSuite);
             this._addAntecedent(postIfLabel, this._currentFlowNode);
             // Now handle the else clause if it's present. If there
             // are chained "else if" statements, they'll be handled
             // recursively here.
             this._currentFlowNode =
                 constExprValue === true ? Binder._unreachableFlowNode : this._finishFlowLabel(elseLabel);
-            if (node.elseSuite) {
-                this.walk(node.elseSuite);
+            if (node.d.elseSuite) {
+                this.walk(node.d.elseSuite);
             }
             else {
-                this._bindNeverCondition(node.testExpression, postIfLabel, /* isPositiveTest */ false);
+                this._bindNeverCondition(node.d.testExpr, postIfLabel, /* isPositiveTest */ false);
             }
             this._addAntecedent(postIfLabel, this._currentFlowNode);
             this._currentFlowNode = this._finishFlowLabel(postIfLabel);
@@ -973,22 +969,22 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         const postWhileLabel = this._createBranchLabel();
         // Determine if the test condition is always true or always false. If so,
         // we can treat either the while or the else clause as unconditional.
-        const constExprValue = StaticExpressions.evaluateStaticBoolLikeExpression(node.testExpression, this._fileInfo.executionEnvironment, this._fileInfo.definedConstants, this._typingImportAliases, this._sysImportAliases);
+        const constExprValue = StaticExpressions.evaluateStaticBoolLikeExpression(node.d.testExpr, this._fileInfo.executionEnvironment, this._fileInfo.definedConstants, this._typingImportAliases, this._sysImportAliases);
         const preLoopLabel = this._createLoopLabel();
         this._addAntecedent(preLoopLabel, this._currentFlowNode);
         this._currentFlowNode = preLoopLabel;
-        this._bindConditional(node.testExpression, thenLabel, elseLabel);
+        this._bindConditional(node.d.testExpr, thenLabel, elseLabel);
         // Handle the while clause.
         this._currentFlowNode =
             constExprValue === false ? Binder._unreachableFlowNode : this._finishFlowLabel(thenLabel);
         this._bindLoopStatement(preLoopLabel, postWhileLabel, () => {
-            this.walk(node.whileSuite);
+            this.walk(node.d.whileSuite);
         });
         this._addAntecedent(preLoopLabel, this._currentFlowNode);
         this._currentFlowNode =
             constExprValue === true ? Binder._unreachableFlowNode : this._finishFlowLabel(elseLabel);
-        if (node.elseSuite) {
-            this.walk(node.elseSuite);
+        if (node.d.elseSuite) {
+            this.walk(node.d.elseSuite);
         }
         this._addAntecedent(postWhileLabel, this._currentFlowNode);
         this._currentFlowNode = this._finishFlowLabel(postWhileLabel);
@@ -997,45 +993,45 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     visitAssert(node) {
         const assertTrueLabel = this._createBranchLabel();
         const assertFalseLabel = this._createBranchLabel();
-        this._bindConditional(node.testExpression, assertTrueLabel, assertFalseLabel);
-        if (node.exceptionExpression) {
+        this._bindConditional(node.d.testExpr, assertTrueLabel, assertFalseLabel);
+        if (node.d.exceptionExpr) {
             this._currentFlowNode = this._finishFlowLabel(assertFalseLabel);
-            this.walk(node.exceptionExpression);
+            this.walk(node.d.exceptionExpr);
         }
         this._currentFlowNode = this._finishFlowLabel(assertTrueLabel);
         return false;
     }
     visitExcept(node) {
-        if (node.typeExpression) {
-            this.walk(node.typeExpression);
+        if (node.d.typeExpr) {
+            this.walk(node.d.typeExpr);
         }
-        if (node.name) {
-            this.walk(node.name);
-            const symbol = this._bindNameToScope(this._currentScope, node.name);
-            this._createAssignmentTargetFlowNodes(node.name, /* walkTargets */ true, /* unbound */ false);
+        if (node.d.name) {
+            this.walk(node.d.name);
+            const symbol = this._bindNameToScope(this._currentScope, node.d.name);
+            this._createAssignmentTargetFlowNodes(node.d.name, /* walkTargets */ true, /* unbound */ false);
             if (symbol) {
                 const declaration = {
                     type: 1 /* DeclarationType.Variable */,
-                    node: node.name,
-                    isConstant: (0, symbolNameUtils_1.isConstantName)(node.name.value),
+                    node: node.d.name,
+                    isConstant: (0, symbolNameUtils_1.isConstantName)(node.d.name.d.value),
                     inferredTypeSource: node,
                     uri: this._fileInfo.fileUri,
-                    range: (0, positionUtils_1.convertTextRangeToRange)(node.name, this._fileInfo.lines),
+                    range: (0, positionUtils_1.convertTextRangeToRange)(node.d.name, this._fileInfo.lines),
                     moduleName: this._fileInfo.moduleName,
                     isInExceptSuite: this._isInExceptSuite,
-                    isExplicitBinding: this._currentScope.getBindingType(node.name.value) !== undefined,
+                    isExplicitBinding: this._currentScope.getBindingType(node.d.name.d.value) !== undefined,
                 };
                 symbol.addDeclaration(declaration);
             }
         }
         const wasInExceptSuite = this._isInExceptSuite;
         this._isInExceptSuite = true;
-        this.walk(node.exceptSuite);
+        this.walk(node.d.exceptSuite);
         this._isInExceptSuite = wasInExceptSuite;
-        if (node.name) {
+        if (node.d.name) {
             // The exception name is implicitly unbound at the end of
             // the except block.
-            this._createFlowAssignment(node.name, /* unbound */ true);
+            this._createFlowAssignment(node.d.name, /* unbound */ true);
         }
         return false;
     }
@@ -1049,14 +1045,14 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             }
             this._targetFunctionDeclaration.raiseStatements.push(node);
         }
-        if (node.typeExpression) {
-            this.walk(node.typeExpression);
+        if (node.d.typeExpression) {
+            this.walk(node.d.typeExpression);
         }
-        if (node.valueExpression) {
-            this.walk(node.valueExpression);
+        if (node.d.valueExpression) {
+            this.walk(node.d.valueExpression);
         }
-        if (node.tracebackExpression) {
-            this.walk(node.tracebackExpression);
+        if (node.d.tracebackExpression) {
+            this.walk(node.d.tracebackExpression);
         }
         this._finallyTargets.forEach((target) => {
             this._addAntecedent(target, this._currentFlowNode);
@@ -1101,7 +1097,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         //                         (after finally)
         // Create one flow label for every except clause.
         const preTryFlowNode = this._currentFlowNode;
-        const curExceptTargets = node.exceptClauses.map(() => this._createBranchLabel());
+        const curExceptTargets = node.d.exceptClauses.map(() => this._createBranchLabel());
         const preFinallyLabel = this._createBranchLabel(preTryFlowNode);
         let isAfterElseAndExceptsReachable = false;
         // Create a label for all of the return or raise labels that are
@@ -1114,12 +1110,12 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             antecedent: preFinallyReturnOrRaiseLabel,
         };
         preFinallyLabel.affectedExpressions = this._trackCodeFlowExpressions(() => {
-            if (node.finallySuite) {
+            if (node.d.finallySuite) {
                 this._addAntecedent(preFinallyLabel, preFinallyGate);
             }
             // Add the finally target as an exception target unless there is
             // a "bare" except clause that accepts all exception types.
-            const hasBareExceptClause = node.exceptClauses.some((except) => !except.typeExpression);
+            const hasBareExceptClause = node.d.exceptClauses.some((except) => !except.d.typeExpr);
             if (!hasBareExceptClause) {
                 curExceptTargets.push(preFinallyReturnOrRaiseLabel);
             }
@@ -1134,24 +1130,24 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             // a single level of finally statements, and we handle most cases
             // involving nesting. Returns or raises within the try/except/raise
             // block will execute the finally target(s).
-            if (node.finallySuite) {
+            if (node.d.finallySuite) {
                 this._finallyTargets.push(preFinallyReturnOrRaiseLabel);
             }
             // Handle the try block.
             this._useExceptTargets(curExceptTargets, () => {
-                this.walk(node.trySuite);
+                this.walk(node.d.trySuite);
             });
             // Handle the else block, which is executed only if
             // execution falls through the try block.
-            if (node.elseSuite) {
-                this.walk(node.elseSuite);
+            if (node.d.elseSuite) {
+                this.walk(node.d.elseSuite);
             }
             this._addAntecedent(preFinallyLabel, this._currentFlowNode);
             if (!this._isCodeUnreachable()) {
                 isAfterElseAndExceptsReachable = true;
             }
             // Handle the except blocks.
-            node.exceptClauses.forEach((exceptNode, index) => {
+            node.d.exceptClauses.forEach((exceptNode, index) => {
                 this._currentFlowNode = this._finishFlowLabel(curExceptTargets[index]);
                 this.walk(exceptNode);
                 this._addAntecedent(preFinallyLabel, this._currentFlowNode);
@@ -1159,20 +1155,20 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                     isAfterElseAndExceptsReachable = true;
                 }
             });
-            if (node.finallySuite) {
+            if (node.d.finallySuite) {
                 this._finallyTargets.pop();
             }
             // Handle the finally block.
             this._currentFlowNode = this._finishFlowLabel(preFinallyLabel);
         });
-        if (node.finallySuite) {
-            this.walk(node.finallySuite);
+        if (node.d.finallySuite) {
+            this.walk(node.d.finallySuite);
             // Add a post-finally node at the end. If we traverse this node,
             // we'll set the "ignore" flag in the pre-finally node.
             const postFinallyNode = {
                 flags: codeFlowTypes_1.FlowFlags.PostFinally,
                 id: this._getUniqueFlowNodeId(),
-                finallyNode: node.finallySuite,
+                finallyNode: node.d.finallySuite,
                 antecedent: this._currentFlowNode,
                 preFinallyGate,
             };
@@ -1184,7 +1180,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         var _a;
         // Make sure this is within an async lambda or function.
         const enclosingFunction = ParseTreeUtils.getEnclosingFunction(node);
-        if (enclosingFunction === undefined || !enclosingFunction.isAsync) {
+        if (enclosingFunction === undefined || !enclosingFunction.d.isAsync) {
             if (this._fileInfo.ipythonMode && enclosingFunction === undefined) {
                 // Top level await is allowed in ipython mode.
                 return true;
@@ -1200,8 +1196,8 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitGlobal(node) {
         const globalScope = this._currentScope.getGlobalScope().scope;
-        node.nameList.forEach((name) => {
-            const nameValue = name.value;
+        node.d.targets.forEach((name) => {
+            const nameValue = name.d.value;
             // Is the binding inconsistent?
             if (this._currentScope.getBindingType(nameValue) === 0 /* NameBindingType.Nonlocal */) {
                 this._addSyntaxError(localize_1.LocMessage.nonLocalRedefinition().format({ name: nameValue }), name);
@@ -1225,8 +1221,8 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             this._addSyntaxError(localize_1.LocMessage.nonLocalInModule(), node);
         }
         else {
-            node.nameList.forEach((name) => {
-                const nameValue = name.value;
+            node.d.targets.forEach((name) => {
+                const nameValue = name.d.value;
                 // Is the binding inconsistent?
                 if (this._currentScope.getBindingType(nameValue) === 1 /* NameBindingType.Global */) {
                     this._addSyntaxError(localize_1.LocMessage.globalRedefinition().format({ name: nameValue }), name);
@@ -1248,27 +1244,27 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitImportAs(node) {
         var _a, _b, _c, _d, _e, _f;
-        if (node.module.nameParts.length > 0) {
-            const firstNamePartValue = node.module.nameParts[0].value;
+        if (node.d.module.d.nameParts.length > 0) {
+            const firstNamePartValue = node.d.module.d.nameParts[0].d.value;
             let symbolName;
             let symbolNameNode;
-            if (node.alias) {
+            if (node.d.alias) {
                 // The symbol name is defined by the alias.
-                symbolName = node.alias.value;
-                symbolNameNode = node.alias;
+                symbolName = node.d.alias.d.value;
+                symbolNameNode = node.d.alias;
             }
             else {
                 // There was no alias, so we need to use the first element of
                 // the name parts as the symbol.
                 symbolName = firstNamePartValue;
-                symbolNameNode = node.module.nameParts[0];
+                symbolNameNode = node.d.module.d.nameParts[0];
             }
             const symbol = this._bindNameToScope(this._currentScope, symbolNameNode);
             if (symbol &&
                 (this._currentScope.type === 4 /* ScopeType.Module */ || this._currentScope.type === 5 /* ScopeType.Builtin */) &&
-                (!node.alias ||
-                    node.module.nameParts.length !== 1 ||
-                    node.module.nameParts[0].value !== node.alias.value)) {
+                (!node.d.alias ||
+                    node.d.module.d.nameParts.length !== 1 ||
+                    node.d.module.d.nameParts[0].d.value !== node.d.alias.d.value)) {
                 if (this._fileInfo.isStubFile || this._fileInfo.isInPyTypedPackage) {
                     // PEP 484 indicates that imported symbols should not be
                     // considered "reexported" from a type stub file unless
@@ -1277,21 +1273,21 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                     this._potentialHiddenSymbols.set(symbolName, symbol);
                 }
             }
-            const importInfo = AnalyzerNodeInfo.getImportInfo(node.module);
+            const importInfo = AnalyzerNodeInfo.getImportInfo(node.d.module);
             (0, debug_1.assert)(importInfo !== undefined);
             if (symbol) {
-                this._createAliasDeclarationForMultipartImportName(node, node.alias, importInfo, symbol);
+                this._createAliasDeclarationForMultipartImportName(node, node.d.alias, importInfo, symbol);
             }
-            this._createFlowAssignment(node.alias ? node.alias : node.module.nameParts[0]);
-            if (node.module.nameParts.length === 1) {
+            this._createFlowAssignment(node.d.alias ? node.d.alias : node.d.module.d.nameParts[0]);
+            if (node.d.module.d.nameParts.length === 1) {
                 if (firstNamePartValue === 'typing' || firstNamePartValue === 'typing_extensions') {
-                    this._typingImportAliases.push((_b = (_a = node.alias) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : firstNamePartValue);
+                    this._typingImportAliases.push((_b = (_a = node.d.alias) === null || _a === void 0 ? void 0 : _a.d.value) !== null && _b !== void 0 ? _b : firstNamePartValue);
                 }
                 else if (firstNamePartValue === 'sys') {
-                    this._sysImportAliases.push((_d = (_c = node.alias) === null || _c === void 0 ? void 0 : _c.value) !== null && _d !== void 0 ? _d : firstNamePartValue);
+                    this._sysImportAliases.push((_d = (_c = node.d.alias) === null || _c === void 0 ? void 0 : _c.d.value) !== null && _d !== void 0 ? _d : firstNamePartValue);
                 }
                 else if (firstNamePartValue === 'dataclasses') {
-                    this._dataclassesImportAliases.push((_f = (_e = node.alias) === null || _e === void 0 ? void 0 : _e.value) !== null && _f !== void 0 ? _f : firstNamePartValue);
+                    this._dataclassesImportAliases.push((_f = (_e = node.d.alias) === null || _e === void 0 ? void 0 : _e.d.value) !== null && _f !== void 0 ? _f : firstNamePartValue);
                 }
             }
         }
@@ -1301,7 +1297,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         var _a;
         const typingSymbolsOfInterest = ['Final', 'ClassVar', 'Annotated'];
         const dataclassesSymbolsOfInterest = ['InitVar'];
-        const importInfo = AnalyzerNodeInfo.getImportInfo(node.module);
+        const importInfo = AnalyzerNodeInfo.getImportInfo(node.d.module);
         AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
         let resolvedPath = uri_1.Uri.empty();
         if (importInfo && importInfo.isImportFound && !importInfo.isNativeLib) {
@@ -1314,11 +1310,11 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         // submodule. In that case, we want to the symbol to appear later in the
         // declaration list because it should "win" when resolving the alias.
         const fileName = (0, pathUtils_1.stripFileExtension)(this._fileInfo.fileUri.fileName);
-        const isModuleInitFile = fileName === '__init__' && node.module.leadingDots === 1 && node.module.nameParts.length === 1;
+        const isModuleInitFile = fileName === '__init__' && node.d.module.d.leadingDots === 1 && node.d.module.d.nameParts.length === 1;
         let isTypingImport = false;
         let isDataclassesImport = false;
-        if (node.module.nameParts.length === 1) {
-            const firstNamePartValue = node.module.nameParts[0].value;
+        if (node.d.module.d.nameParts.length === 1) {
+            const firstNamePartValue = node.d.module.d.nameParts[0].d.value;
             if (firstNamePartValue === 'typing' || firstNamePartValue === 'typing_extensions') {
                 isTypingImport = true;
             }
@@ -1326,7 +1322,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 isDataclassesImport = true;
             }
         }
-        if (node.isWildcardImport) {
+        if (node.d.isWildcardImport) {
             if (ParseTreeUtils.getEnclosingClass(node) || ParseTreeUtils.getEnclosingFunction(node)) {
                 this._addSyntaxError(localize_1.LocMessage.wildcardInFunction(), node);
             }
@@ -1342,7 +1338,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                         // If the symbol is going to be immediately replaced with a same-named
                         // imported symbol, skip this.
                         const isImmediatelyReplaced = wildcardNames.some((name) => {
-                            return name === node.module.nameParts[0].value;
+                            return name === node.d.module.d.nameParts[0].d.value;
                         });
                         if (!isImmediatelyReplaced) {
                             this._addImplicitFromImport(node, importInfo);
@@ -1422,25 +1418,25 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             if (isModuleInitFile) {
                 this._addImplicitFromImport(node, importInfo);
             }
-            node.imports.forEach((importSymbolNode) => {
-                const importedName = importSymbolNode.name.value;
-                const nameNode = importSymbolNode.alias || importSymbolNode.name;
+            node.d.imports.forEach((importSymbolNode) => {
+                const importedName = importSymbolNode.d.name.d.value;
+                const nameNode = importSymbolNode.d.alias || importSymbolNode.d.name;
                 AnalyzerNodeInfo.setFlowNode(importSymbolNode, this._currentFlowNode);
                 const symbol = this._bindNameToScope(this._currentScope, nameNode);
                 if (symbol) {
                     // All import statements of the form `from . import x` treat x
                     // as an externally-visible (not hidden) symbol.
-                    if (node.module.nameParts.length > 0) {
+                    if (node.d.module.d.nameParts.length > 0) {
                         if (this._currentScope.type === 4 /* ScopeType.Module */ ||
                             this._currentScope.type === 5 /* ScopeType.Builtin */) {
-                            if (!importSymbolNode.alias ||
-                                importSymbolNode.alias.value !== importSymbolNode.name.value) {
+                            if (!importSymbolNode.d.alias ||
+                                importSymbolNode.d.alias.d.value !== importSymbolNode.d.name.d.value) {
                                 if (this._fileInfo.isStubFile || this._fileInfo.isInPyTypedPackage) {
                                     // PEP 484 indicates that imported symbols should not be
                                     // considered "reexported" from a type stub file unless
                                     // they are imported using the "as" form using a redundant form.
                                     // Py.typed packages follow the same rule as PEP 484.
-                                    this._potentialHiddenSymbols.set(nameNode.value, symbol);
+                                    this._potentialHiddenSymbols.set(nameNode.d.value, symbol);
                                 }
                             }
                         }
@@ -1460,7 +1456,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                             loadSymbolsFromPath: true,
                             range: (0, textRange_1.getEmptyRange)(),
                             usesLocalName: false,
-                            moduleName: this._formatModuleName(node.module),
+                            moduleName: this._formatModuleName(node.d.module),
                             isInExceptSuite: this._isInExceptSuite,
                         };
                         // Handle the case where this is an __init__.py file and the imported
@@ -1469,7 +1465,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                         // an absolute import (e.g. "from A.B.C import X"). In this case, we want to
                         // always resolve to the submodule rather than the resolved path.
                         if (fileName === '__init__') {
-                            if (node.module.leadingDots === 1 && node.module.nameParts.length === 0) {
+                            if (node.d.module.d.leadingDots === 1 && node.d.module.d.nameParts.length === 0) {
                                 loadSymbolsFromPath = false;
                             }
                             else if (resolvedPath.equals(this._fileInfo.fileUri)) {
@@ -1482,24 +1478,24 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                         node: importSymbolNode,
                         uri: resolvedPath,
                         loadSymbolsFromPath,
-                        usesLocalName: !!importSymbolNode.alias,
+                        usesLocalName: !!importSymbolNode.d.alias,
                         symbolName: importedName,
                         submoduleFallback,
                         range: (0, positionUtils_1.convertTextRangeToRange)(nameNode, this._fileInfo.lines),
-                        moduleName: this._formatModuleName(node.module),
+                        moduleName: this._formatModuleName(node.d.module),
                         isInExceptSuite: this._isInExceptSuite,
                         isNativeLib: importInfo === null || importInfo === void 0 ? void 0 : importInfo.isNativeLib,
                     };
                     symbol.addDeclaration(aliasDecl);
-                    this._createFlowAssignment(importSymbolNode.alias || importSymbolNode.name);
+                    this._createFlowAssignment(importSymbolNode.d.alias || importSymbolNode.d.name);
                     if (isTypingImport) {
-                        if (typingSymbolsOfInterest.some((s) => s === importSymbolNode.name.value)) {
-                            this._typingSymbolAliases.set(nameNode.value, importSymbolNode.name.value);
+                        if (typingSymbolsOfInterest.some((s) => s === importSymbolNode.d.name.d.value)) {
+                            this._typingSymbolAliases.set(nameNode.d.value, importSymbolNode.d.name.d.value);
                         }
                     }
                     if (isDataclassesImport) {
-                        if (dataclassesSymbolsOfInterest.some((s) => s === importSymbolNode.name.value)) {
-                            this._dataclassesSymbolAliases.set(nameNode.value, importSymbolNode.name.value);
+                        if (dataclassesSymbolsOfInterest.some((s) => s === importSymbolNode.d.name.d.value)) {
+                            this._dataclassesSymbolAliases.set(nameNode.d.value, importSymbolNode.d.name.d.value);
                         }
                     }
                 }
@@ -1508,12 +1504,12 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitWith(node) {
-        node.withItems.forEach((item) => {
-            this.walk(item.expression);
-            if (item.target) {
-                this._bindPossibleTupleNamedTarget(item.target);
-                this._addInferredTypeAssignmentForVariable(item.target, item);
-                this._createAssignmentTargetFlowNodes(item.target, /* walkTargets */ true, /* unbound */ false);
+        node.d.withItems.forEach((item) => {
+            this.walk(item.d.expr);
+            if (item.d.target) {
+                this._bindPossibleTupleNamedTarget(item.d.target);
+                this._addInferredTypeAssignmentForVariable(item.d.target, item);
+                this._createAssignmentTargetFlowNodes(item.d.target, /* walkTargets */ true, /* unbound */ false);
             }
         });
         // We need to treat the "with" body as though it is wrapped in a try/except
@@ -1540,10 +1536,10 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         // In addition to the ContextManagerSwallowExceptionTarget, we'll create
         // a second target called ContextManagerForwardExceptionTarget that forwards
         // exceptions to existing exception targets if they exist.
-        const contextManagerSwallowExceptionTarget = this._createContextManagerLabel(node.withItems.map((item) => item.expression), !!node.isAsync, 
+        const contextManagerSwallowExceptionTarget = this._createContextManagerLabel(node.d.withItems.map((item) => item.d.expr), !!node.d.isAsync, 
         /* blockIfSwallowsExceptions */ false);
         this._addAntecedent(contextManagerSwallowExceptionTarget, this._currentFlowNode);
-        const contextManagerForwardExceptionTarget = this._createContextManagerLabel(node.withItems.map((item) => item.expression), !!node.isAsync, 
+        const contextManagerForwardExceptionTarget = this._createContextManagerLabel(node.d.withItems.map((item) => item.d.expr), !!node.d.isAsync, 
         /* blockIfSwallowsExceptions */ true);
         this._currentExceptTargets.forEach((exceptionTarget) => {
             this._addAntecedent(exceptionTarget, contextManagerForwardExceptionTarget);
@@ -1553,7 +1549,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         this._addAntecedent(postContextManagerLabel, contextManagerSwallowExceptionTarget);
         postContextManagerLabel.affectedExpressions = this._trackCodeFlowExpressions(() => {
             this._useExceptTargets([contextManagerSwallowExceptionTarget, contextManagerForwardExceptionTarget], () => {
-                this.walk(node.suite);
+                this.walk(node.d.suite);
             });
             this._addAntecedent(postContextManagerLabel, this._currentFlowNode);
             this._currentFlowNode = postContextManagerLabel;
@@ -1561,11 +1557,11 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             if (!this._isCodeUnreachable()) {
                 this._addExceptTargets(this._currentFlowNode);
             }
-            if (node.asyncToken && !this._fileInfo.ipythonMode) {
+            if (node.d.asyncToken && !this._fileInfo.ipythonMode) {
                 // Top level async with is allowed in ipython mode.
                 const enclosingFunction = ParseTreeUtils.getEnclosingFunction(node);
-                if (!enclosingFunction || !enclosingFunction.isAsync) {
-                    this._addSyntaxError(localize_1.LocMessage.asyncNotInAsyncFunction(), node.asyncToken);
+                if (!enclosingFunction || !enclosingFunction.d.isAsync) {
+                    this._addSyntaxError(localize_1.LocMessage.asyncNotInAsyncFunction(), node.d.asyncToken);
                 }
             }
         });
@@ -1578,23 +1574,23 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         const postExpressionLabel = this._createBranchLabel(preTernaryFlowNode);
         postExpressionLabel.affectedExpressions = this._trackCodeFlowExpressions(() => {
             // Handle the test expression.
-            this._bindConditional(node.testExpression, trueLabel, falseLabel);
+            this._bindConditional(node.d.testExpr, trueLabel, falseLabel);
             // Handle the "true" portion (the "if" expression).
             this._currentFlowNode = this._finishFlowLabel(trueLabel);
-            this.walk(node.ifExpression);
+            this.walk(node.d.ifExpr);
             this._addAntecedent(postExpressionLabel, this._currentFlowNode);
             // Handle the "false" portion (the "else" expression).
             this._currentFlowNode = this._finishFlowLabel(falseLabel);
-            this.walk(node.elseExpression);
+            this.walk(node.d.elseExpr);
             this._addAntecedent(postExpressionLabel, this._currentFlowNode);
             this._currentFlowNode = this._finishFlowLabel(postExpressionLabel);
         });
         return false;
     }
     visitUnaryOperation(node) {
-        if (node.operator === 38 /* OperatorType.Not */ && this._currentFalseTarget && this._currentTrueTarget) {
+        if (node.d.operator === 38 /* OperatorType.Not */ && this._currentFalseTarget && this._currentTrueTarget) {
             // Swap the existing true/false targets.
-            this._bindConditional(node.expression, this._currentFalseTarget, this._currentTrueTarget);
+            this._bindConditional(node.d.expr, this._currentFalseTarget, this._currentTrueTarget);
         }
         else {
             // Temporarily set the true/false targets to undefined because
@@ -1602,13 +1598,13 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             // (AND/OR/NOT subexpressions).
             this._disableTrueFalseTargets(() => {
                 // Evaluate the operand expression.
-                this.walk(node.expression);
+                this.walk(node.d.expr);
             });
         }
         return false;
     }
     visitBinaryOperation(node) {
-        if (node.operator === 36 /* OperatorType.And */ || node.operator === 37 /* OperatorType.Or */) {
+        if (node.d.operator === 36 /* OperatorType.And */ || node.d.operator === 37 /* OperatorType.Or */) {
             let trueTarget = this._currentTrueTarget;
             let falseTarget = this._currentFalseTarget;
             let postRightLabel;
@@ -1617,14 +1613,14 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 trueTarget = falseTarget = postRightLabel;
             }
             const preRightLabel = this._createBranchLabel();
-            if (node.operator === 36 /* OperatorType.And */) {
-                this._bindConditional(node.leftExpression, preRightLabel, falseTarget);
+            if (node.d.operator === 36 /* OperatorType.And */) {
+                this._bindConditional(node.d.leftExpr, preRightLabel, falseTarget);
             }
             else {
-                this._bindConditional(node.leftExpression, trueTarget, preRightLabel);
+                this._bindConditional(node.d.leftExpr, trueTarget, preRightLabel);
             }
             this._currentFlowNode = this._finishFlowLabel(preRightLabel);
-            this._bindConditional(node.rightExpression, trueTarget, falseTarget);
+            this._bindConditional(node.d.rightExpr, trueTarget, falseTarget);
             if (postRightLabel) {
                 this._currentFlowNode = this._finishFlowLabel(postRightLabel);
             }
@@ -1634,8 +1630,8 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             // this binary operation is not part of a chain of logical expressions
             // (AND/OR/NOT subexpressions).
             this._disableTrueFalseTargets(() => {
-                this.walk(node.leftExpression);
-                this.walk(node.rightExpression);
+                this.walk(node.d.leftExpr);
+                this.walk(node.d.rightExpr);
             });
         }
         return false;
@@ -1643,8 +1639,8 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     visitComprehension(node) {
         const enclosingFunction = ParseTreeUtils.getEnclosingFunction(node);
         // The first iterable is executed outside of the comprehension scope.
-        if (node.forIfNodes.length > 0 && node.forIfNodes[0].nodeType === 12 /* ParseNodeType.ComprehensionFor */) {
-            this.walk(node.forIfNodes[0].iterableExpression);
+        if (node.d.forIfNodes.length > 0 && node.d.forIfNodes[0].nodeType === 12 /* ParseNodeType.ComprehensionFor */) {
+            this.walk(node.d.forIfNodes[0].d.iterableExpr);
         }
         this._createNewScope(1 /* ScopeType.Comprehension */, this._getNonClassParentScope(), 
         /* proxyScope */ undefined, () => {
@@ -1654,45 +1650,45 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             // We'll walk the forIfNodes list twice. The first time we'll
             // bind targets of for statements. The second time we'll walk
             // expressions and create the control flow graph.
-            for (let i = 0; i < node.forIfNodes.length; i++) {
-                const compr = node.forIfNodes[i];
+            for (let i = 0; i < node.d.forIfNodes.length; i++) {
+                const compr = node.d.forIfNodes[i];
                 const addedSymbols = new Map();
                 if (compr.nodeType === 12 /* ParseNodeType.ComprehensionFor */) {
-                    this._bindPossibleTupleNamedTarget(compr.targetExpression, addedSymbols);
-                    this._addInferredTypeAssignmentForVariable(compr.targetExpression, compr);
+                    this._bindPossibleTupleNamedTarget(compr.d.targetExpr, addedSymbols);
+                    this._addInferredTypeAssignmentForVariable(compr.d.targetExpr, compr);
                     // Async for is not allowed outside of an async function
                     // unless we're in ipython mode.
-                    if (compr.asyncToken && !this._fileInfo.ipythonMode) {
-                        if (!enclosingFunction || !enclosingFunction.isAsync) {
+                    if (compr.d.asyncToken && !this._fileInfo.ipythonMode) {
+                        if (!enclosingFunction || !enclosingFunction.d.isAsync) {
                             // Allow if it's within a generator expression. Execution of
                             // generator expressions is deferred and therefore can be
                             // run within the context of an async function later.
                             if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 34 /* ParseNodeType.List */) {
-                                this._addSyntaxError(localize_1.LocMessage.asyncNotInAsyncFunction(), compr.asyncToken);
+                                this._addSyntaxError(localize_1.LocMessage.asyncNotInAsyncFunction(), compr.d.asyncToken);
                             }
                         }
                     }
                 }
             }
-            for (let i = 0; i < node.forIfNodes.length; i++) {
-                const compr = node.forIfNodes[i];
+            for (let i = 0; i < node.d.forIfNodes.length; i++) {
+                const compr = node.d.forIfNodes[i];
                 if (compr.nodeType === 12 /* ParseNodeType.ComprehensionFor */) {
                     // We already walked the first iterable expression above,
                     // so skip it here.
                     if (i !== 0) {
-                        this.walk(compr.iterableExpression);
+                        this.walk(compr.d.iterableExpr);
                     }
-                    this._createAssignmentTargetFlowNodes(compr.targetExpression, 
+                    this._createAssignmentTargetFlowNodes(compr.d.targetExpr, 
                     /* walkTargets */ true, 
                     /* unbound */ false);
                 }
                 else {
                     const trueLabel = this._createBranchLabel();
-                    this._bindConditional(compr.testExpression, trueLabel, falseLabel);
+                    this._bindConditional(compr.d.testExpr, trueLabel, falseLabel);
                     this._currentFlowNode = this._finishFlowLabel(trueLabel);
                 }
             }
-            this.walk(node.expression);
+            this.walk(node.d.expr);
             this._addAntecedent(falseLabel, this._currentFlowNode);
             this._currentFlowNode = this._finishFlowLabel(falseLabel);
         });
@@ -1700,9 +1696,9 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitMatch(node) {
         // Evaluate the subject expression.
-        this.walk(node.subjectExpression);
+        this.walk(node.d.expr);
         const expressionList = [];
-        const isSubjectNarrowable = this._isNarrowingExpression(node.subjectExpression, expressionList);
+        const isSubjectNarrowable = this._isNarrowingExpression(node.d.expr, expressionList);
         if (isSubjectNarrowable) {
             expressionList.forEach((expr) => {
                 const referenceKey = (0, codeFlowTypes_1.createKeyForReference)(expr);
@@ -1714,32 +1710,32 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         // Model the match statement as a series of if/elif clauses
         // each of which tests for the specified pattern (and optionally
         // for the guard condition).
-        node.cases.forEach((caseStatement) => {
+        node.d.cases.forEach((caseStatement) => {
             const postCaseLabel = this._createBranchLabel();
             const preGuardLabel = this._createBranchLabel();
             const preSuiteLabel = this._createBranchLabel();
             // Evaluate the pattern.
             this._addAntecedent(preGuardLabel, this._currentFlowNode);
-            if (!caseStatement.isIrrefutable) {
+            if (!caseStatement.d.isIrrefutable) {
                 this._addAntecedent(postCaseLabel, this._currentFlowNode);
             }
-            else if (!caseStatement.guardExpression) {
+            else if (!caseStatement.d.guardExpr) {
                 foundIrrefutableCase = true;
             }
             this._currentFlowNode = this._finishFlowLabel(preGuardLabel);
             // Bind the pattern.
-            this.walk(caseStatement.pattern);
-            this._createFlowNarrowForPattern(node.subjectExpression, caseStatement);
+            this.walk(caseStatement.d.pattern);
+            this._createFlowNarrowForPattern(node.d.expr, caseStatement);
             // Apply the guard expression.
-            if (caseStatement.guardExpression) {
-                this._bindConditional(caseStatement.guardExpression, preSuiteLabel, postCaseLabel);
+            if (caseStatement.d.guardExpr) {
+                this._bindConditional(caseStatement.d.guardExpr, preSuiteLabel, postCaseLabel);
             }
             else {
                 this._addAntecedent(preSuiteLabel, this._currentFlowNode);
             }
             this._currentFlowNode = this._finishFlowLabel(preSuiteLabel);
             // Bind the body of the case statement.
-            this.walk(caseStatement.suite);
+            this.walk(caseStatement.d.suite);
             this._addAntecedent(postMatchLabel, this._currentFlowNode);
             this._currentFlowNode = this._finishFlowLabel(postCaseLabel);
         });
@@ -1747,7 +1743,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         // match statement. This will compute the narrowed type if no case
         // statements are matched.
         if (isSubjectNarrowable) {
-            this._createFlowNarrowForPattern(node.subjectExpression, node);
+            this._createFlowNarrowForPattern(node.d.expr, node);
         }
         // Create an "implied else" to conditionally gate code flow based on
         // whether the narrowed type of the subject expression is Never at this point.
@@ -1760,26 +1756,26 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitPatternAs(node) {
         const postOrLabel = this._createBranchLabel();
-        node.orPatterns.forEach((orPattern) => {
+        node.d.orPatterns.forEach((orPattern) => {
             this.walk(orPattern);
             this._addAntecedent(postOrLabel, this._currentFlowNode);
         });
         this._currentFlowNode = this._finishFlowLabel(postOrLabel);
-        if (node.target) {
-            this.walk(node.target);
-            const symbol = this._bindNameToScope(this._currentScope, node.target);
-            this._createAssignmentTargetFlowNodes(node.target, /* walkTargets */ false, /* unbound */ false);
+        if (node.d.target) {
+            this.walk(node.d.target);
+            const symbol = this._bindNameToScope(this._currentScope, node.d.target);
+            this._createAssignmentTargetFlowNodes(node.d.target, /* walkTargets */ false, /* unbound */ false);
             if (symbol) {
                 const declaration = {
                     type: 1 /* DeclarationType.Variable */,
-                    node: node.target,
-                    isConstant: (0, symbolNameUtils_1.isConstantName)(node.target.value),
+                    node: node.d.target,
+                    isConstant: (0, symbolNameUtils_1.isConstantName)(node.d.target.d.value),
                     inferredTypeSource: node,
                     uri: this._fileInfo.fileUri,
-                    range: (0, positionUtils_1.convertTextRangeToRange)(node.target, this._fileInfo.lines),
+                    range: (0, positionUtils_1.convertTextRangeToRange)(node.d.target, this._fileInfo.lines),
                     moduleName: this._fileInfo.moduleName,
                     isInExceptSuite: this._isInExceptSuite,
-                    isExplicitBinding: this._currentScope.getBindingType(node.target.value) !== undefined,
+                    isExplicitBinding: this._currentScope.getBindingType(node.d.target.d.value) !== undefined,
                 };
                 symbol.addDeclaration(declaration);
             }
@@ -1787,19 +1783,19 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         return false;
     }
     visitPatternCapture(node) {
-        if (!node.isWildcard) {
-            this._addPatternCaptureTarget(node.target);
+        if (!node.d.isWildcard) {
+            this._addPatternCaptureTarget(node.d.target);
         }
         return true;
     }
     visitPatternMappingExpandEntry(node) {
-        if (node.target.value !== '_') {
-            this._addPatternCaptureTarget(node.target);
+        if (node.d.target.d.value !== '_') {
+            this._addPatternCaptureTarget(node.d.target);
         }
         return true;
     }
     _formatModuleName(node) {
-        return '.'.repeat(node.leadingDots) + node.nameParts.map((part) => part.value).join('.');
+        return '.'.repeat(node.d.leadingDots) + node.d.nameParts.map((part) => part.d.value).join('.');
     }
     _getNonClassParentScope() {
         // We may not be able to use the current scope if it's a class scope.
@@ -1814,7 +1810,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         (0, debug_1.assert)(this._currentScope.type === 3 /* ScopeType.Class */);
         let slotsContainsDict = false;
         for (const slotNameNode of slotNameNodes) {
-            const slotName = slotNameNode.strings[0].value;
+            const slotName = slotNameNode.d.strings[0].d.value;
             if (slotName === '__dict__') {
                 slotsContainsDict = true;
                 continue;
@@ -1841,7 +1837,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             symbol.addDeclaration(declaration);
         }
         if (!slotsContainsDict) {
-            this._currentScope.setSlotsNames(slotNameNodes.map((node) => node.strings[0].value));
+            this._currentScope.setSlotsNames(slotNameNodes.map((node) => node.d.strings[0].d.value));
         }
     }
     _isInComprehension(node, ignoreOutermostIterable = false) {
@@ -1850,10 +1846,10 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         let prevPrevNode;
         while (curNode) {
             if (curNode.nodeType === 11 /* ParseNodeType.Comprehension */) {
-                if (ignoreOutermostIterable && curNode.forIfNodes.length > 0) {
-                    const outermostCompr = curNode.forIfNodes[0];
+                if (ignoreOutermostIterable && curNode.d.forIfNodes.length > 0) {
+                    const outermostCompr = curNode.d.forIfNodes[0];
                     if (prevNode === outermostCompr && outermostCompr.nodeType === 12 /* ParseNodeType.ComprehensionFor */) {
-                        if (prevPrevNode === outermostCompr.iterableExpression) {
+                        if (prevPrevNode === outermostCompr.d.iterableExpr) {
                             return false;
                         }
                     }
@@ -1873,13 +1869,13 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             const declaration = {
                 type: 1 /* DeclarationType.Variable */,
                 node: target,
-                isConstant: (0, symbolNameUtils_1.isConstantName)(target.value),
+                isConstant: (0, symbolNameUtils_1.isConstantName)(target.d.value),
                 inferredTypeSource: target.parent,
                 uri: this._fileInfo.fileUri,
                 range: (0, positionUtils_1.convertTextRangeToRange)(target, this._fileInfo.lines),
                 moduleName: this._fileInfo.moduleName,
                 isInExceptSuite: this._isInExceptSuite,
-                isExplicitBinding: this._currentScope.getBindingType(target.value) !== undefined,
+                isExplicitBinding: this._currentScope.getBindingType(target.d.value) !== undefined,
             };
             symbol.addDeclaration(declaration);
         }
@@ -1921,16 +1917,16 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         return undefined;
     }
     _addImplicitFromImport(node, importInfo) {
-        const symbolName = node.module.nameParts[0].value;
+        const symbolName = node.d.module.d.nameParts[0].d.value;
         const symbol = this._bindNameValueToScope(this._currentScope, symbolName);
         if (symbol) {
             this._createAliasDeclarationForMultipartImportName(node, /* importAlias */ undefined, importInfo, symbol);
         }
-        this._createFlowAssignment(node.module.nameParts[0]);
+        this._createFlowAssignment(node.d.module.d.nameParts[0]);
     }
     _createAliasDeclarationForMultipartImportName(node, importAlias, importInfo, symbol) {
         var _a;
-        const firstNamePartValue = node.module.nameParts[0].value;
+        const firstNamePartValue = node.d.module.d.nameParts[0].d.value;
         AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
         // See if there's already a matching alias declaration for this import.
         // if so, we'll update it rather than creating a new one. This is required
@@ -1963,8 +1959,8 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 range: (0, textRange_1.getEmptyRange)(),
                 usesLocalName: !!importAlias,
                 moduleName: importAlias
-                    ? this._formatModuleName(node.module)
-                    : '.'.repeat(node.module.leadingDots) + firstNamePartValue,
+                    ? this._formatModuleName(node.d.module)
+                    : '.'.repeat(node.d.module.d.leadingDots) + firstNamePartValue,
                 firstNamePart: firstNamePartValue,
                 isInExceptSuite: this._isInExceptSuite,
             };
@@ -1982,15 +1978,15 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 usesLocalName: !!importAlias,
                 moduleName: (_a = importInfo === null || importInfo === void 0 ? void 0 : importInfo.importName) !== null && _a !== void 0 ? _a : '',
                 firstNamePart: importAlias
-                    ? this._formatModuleName(node.module)
-                    : '.'.repeat(node.module.leadingDots) + firstNamePartValue,
+                    ? this._formatModuleName(node.d.module)
+                    : '.'.repeat(node.d.module.d.leadingDots) + firstNamePartValue,
                 isUnresolved: true,
                 isInExceptSuite: this._isInExceptSuite,
             };
         }
         // See if there is import info for this part of the path. This allows us
         // to implicitly import all of the modules in a multi-part module name.
-        const implicitImportInfo = AnalyzerNodeInfo.getImportInfo(node.module.nameParts[0]);
+        const implicitImportInfo = AnalyzerNodeInfo.getImportInfo(node.d.module.d.nameParts[0]);
         if (implicitImportInfo && implicitImportInfo.resolvedUris.length) {
             newDecl.uri = implicitImportInfo.resolvedUris[0];
             newDecl.loadSymbolsFromPath = true;
@@ -1998,7 +1994,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         }
         // Add the implicit imports for this module if it's the last
         // name part we're resolving.
-        if (importAlias || node.module.nameParts.length === 1) {
+        if (importAlias || node.d.module.d.nameParts.length === 1) {
             newDecl.uri = uriOfLastSubmodule;
             newDecl.loadSymbolsFromPath = true;
             newDecl.isUnresolved = false;
@@ -2009,8 +2005,8 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         else {
             // Fill in the remaining name parts.
             let curLoaderActions = newDecl;
-            for (let i = 1; i < node.module.nameParts.length; i++) {
-                const namePartValue = node.module.nameParts[i].value;
+            for (let i = 1; i < node.d.module.d.nameParts.length; i++) {
+                const namePartValue = node.d.module.d.nameParts[i].d.value;
                 // Is there an existing loader action for this name?
                 let loaderActions = curLoaderActions.implicitImports
                     ? curLoaderActions.implicitImports.get(namePartValue)
@@ -2031,7 +2027,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                     }
                     curLoaderActions.implicitImports.set(namePartValue, loaderActions);
                 }
-                if (i === node.module.nameParts.length - 1) {
+                if (i === node.d.module.d.nameParts.length - 1) {
                     // If this is the last name part we're resolving, add in the
                     // implicit imports as well.
                     if (importInfo && i < importInfo.resolvedUris.length) {
@@ -2045,7 +2041,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                     // is import info for this part of the path. This allows us to implicitly
                     // import all of the modules in a multi-part module name (e.g. "import a.b.c"
                     // imports "a" and "a.b" and "a.b.c").
-                    const implicitImportInfo = AnalyzerNodeInfo.getImportInfo(node.module.nameParts[i]);
+                    const implicitImportInfo = AnalyzerNodeInfo.getImportInfo(node.d.module.d.nameParts[i]);
                     if (implicitImportInfo && implicitImportInfo.resolvedUris.length) {
                         loaderActions.uri = implicitImportInfo.resolvedUris[i];
                         loaderActions.loadSymbolsFromPath = true;
@@ -2178,12 +2174,12 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     // positive or negative case).
     _bindNeverCondition(node, target, isPositiveTest) {
         const expressionList = [];
-        if (node.nodeType === 55 /* ParseNodeType.UnaryOperation */ && node.operator === 38 /* OperatorType.Not */) {
-            this._bindNeverCondition(node.expression, target, !isPositiveTest);
+        if (node.nodeType === 55 /* ParseNodeType.UnaryOperation */ && node.d.operator === 38 /* OperatorType.Not */) {
+            this._bindNeverCondition(node.d.expr, target, !isPositiveTest);
         }
         else if (node.nodeType === 7 /* ParseNodeType.BinaryOperation */ &&
-            (node.operator === 36 /* OperatorType.And */ || node.operator === 37 /* OperatorType.Or */)) {
-            let isAnd = node.operator === 36 /* OperatorType.And */;
+            (node.d.operator === 36 /* OperatorType.And */ || node.d.operator === 37 /* OperatorType.Or */)) {
+            let isAnd = node.d.operator === 36 /* OperatorType.And */;
             if (isPositiveTest) {
                 isAnd = !isAnd;
             }
@@ -2191,22 +2187,22 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 // In the And case, we need to gate the synthesized else clause if both
                 // of the operands evaluate to never once they are narrowed.
                 const savedCurrentFlowNode = this._currentFlowNode;
-                this._bindNeverCondition(node.leftExpression, target, isPositiveTest);
+                this._bindNeverCondition(node.d.leftExpr, target, isPositiveTest);
                 this._currentFlowNode = savedCurrentFlowNode;
-                this._bindNeverCondition(node.rightExpression, target, isPositiveTest);
+                this._bindNeverCondition(node.d.rightExpr, target, isPositiveTest);
             }
             else {
                 const initialCurrentFlowNode = this._currentFlowNode;
                 // In the Or case, we need to gate the synthesized else clause if either
                 // of the operands evaluate to never.
                 const afterLabel = this._createBranchLabel();
-                this._bindNeverCondition(node.leftExpression, afterLabel, isPositiveTest);
+                this._bindNeverCondition(node.d.leftExpr, afterLabel, isPositiveTest);
                 // If the condition didn't result in any new flow nodes, we can skip
                 // checking the other condition.
                 if (initialCurrentFlowNode !== this._currentFlowNode) {
                     this._currentFlowNode = this._finishFlowLabel(afterLabel);
                     const prevCurrentNode = this._currentFlowNode;
-                    this._bindNeverCondition(node.rightExpression, target, isPositiveTest);
+                    this._bindNeverCondition(node.d.rightExpr, target, isPositiveTest);
                     // If the second condition resulted in no new control flow node, we can
                     // eliminate this entire subgraph.
                     if (prevCurrentNode === this._currentFlowNode) {
@@ -2285,10 +2281,10 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     _isLogicalExpression(expression) {
         switch (expression.nodeType) {
             case 55 /* ParseNodeType.UnaryOperation */: {
-                return expression.operator === 38 /* OperatorType.Not */;
+                return expression.d.operator === 38 /* OperatorType.Not */;
             }
             case 7 /* ParseNodeType.BinaryOperation */: {
-                return expression.operator === 36 /* OperatorType.And */ || expression.operator === 37 /* OperatorType.Or */;
+                return expression.d.operator === 36 /* OperatorType.And */ || expression.d.operator === 37 /* OperatorType.Or */;
             }
         }
         return false;
@@ -2326,19 +2322,19 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                         // leftExpression to the expression list because that expression
                         // can be narrowed based on the attribute type.
                         if (expression.nodeType === 35 /* ParseNodeType.MemberAccess */) {
-                            if ((0, codeFlowTypes_1.isCodeFlowSupportedForReference)(expression.leftExpression)) {
-                                expressionList.push(expression.leftExpression);
+                            if ((0, codeFlowTypes_1.isCodeFlowSupportedForReference)(expression.d.leftExpr)) {
+                                expressionList.push(expression.d.leftExpr);
                             }
                         }
                         // If the expression is an index expression with a supported
                         // subscript, add its baseExpression to the expression list because
                         // that expression can be narrowed.
                         if (expression.nodeType === 27 /* ParseNodeType.Index */ &&
-                            expression.items.length === 1 &&
-                            !expression.trailingComma &&
-                            expression.items[0].argumentCategory === 0 /* ArgumentCategory.Simple */) {
-                            if ((0, codeFlowTypes_1.isCodeFlowSupportedForReference)(expression.baseExpression)) {
-                                expressionList.push(expression.baseExpression);
+                            expression.d.items.length === 1 &&
+                            !expression.d.trailingComma &&
+                            expression.d.items[0].d.argCategory === 0 /* ArgumentCategory.Simple */) {
+                            if ((0, codeFlowTypes_1.isCodeFlowSupportedForReference)(expression.d.leftExpr)) {
+                                expressionList.push(expression.d.leftExpr);
                             }
                         }
                     }
@@ -2347,33 +2343,33 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 return false;
             }
             case 4 /* ParseNodeType.AssignmentExpression */: {
-                expressionList.push(expression.name);
-                this._isNarrowingExpression(expression.rightExpression, expressionList, filterForNeverNarrowing, 
+                expressionList.push(expression.d.name);
+                this._isNarrowingExpression(expression.d.rightExpr, expressionList, filterForNeverNarrowing, 
                 /* isComplexExpression */ true);
                 return true;
             }
             case 7 /* ParseNodeType.BinaryOperation */: {
-                const isOrIsNotOperator = expression.operator === 39 /* OperatorType.Is */ || expression.operator === 40 /* OperatorType.IsNot */;
-                const equalsOrNotEqualsOperator = expression.operator === 12 /* OperatorType.Equals */ || expression.operator === 28 /* OperatorType.NotEquals */;
+                const isOrIsNotOperator = expression.d.operator === 39 /* OperatorType.Is */ || expression.d.operator === 40 /* OperatorType.IsNot */;
+                const equalsOrNotEqualsOperator = expression.d.operator === 12 /* OperatorType.Equals */ || expression.d.operator === 28 /* OperatorType.NotEquals */;
                 if (isOrIsNotOperator || equalsOrNotEqualsOperator) {
                     // Look for "X is None", "X is not None", "X == None", "X != None".
                     // These are commonly-used patterns used in control flow.
-                    if (expression.rightExpression.nodeType === 14 /* ParseNodeType.Constant */ &&
-                        expression.rightExpression.constType === 26 /* KeywordType.None */) {
-                        return this._isNarrowingExpression(expression.leftExpression, expressionList, filterForNeverNarrowing, 
+                    if (expression.d.rightExpr.nodeType === 14 /* ParseNodeType.Constant */ &&
+                        expression.d.rightExpr.d.constType === 26 /* KeywordType.None */) {
+                        return this._isNarrowingExpression(expression.d.leftExpr, expressionList, filterForNeverNarrowing, 
                         /* isComplexExpression */ true);
                     }
                     // Look for "type(X) is Y" or "type(X) is not Y".
                     if (isOrIsNotOperator &&
-                        expression.leftExpression.nodeType === 9 /* ParseNodeType.Call */ &&
-                        expression.leftExpression.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
-                        expression.leftExpression.leftExpression.value === 'type' &&
-                        expression.leftExpression.arguments.length === 1 &&
-                        expression.leftExpression.arguments[0].argumentCategory === 0 /* ArgumentCategory.Simple */) {
-                        return this._isNarrowingExpression(expression.leftExpression.arguments[0].valueExpression, expressionList, filterForNeverNarrowing, 
+                        expression.d.leftExpr.nodeType === 9 /* ParseNodeType.Call */ &&
+                        expression.d.leftExpr.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ &&
+                        expression.d.leftExpr.d.leftExpr.d.value === 'type' &&
+                        expression.d.leftExpr.d.args.length === 1 &&
+                        expression.d.leftExpr.d.args[0].d.argCategory === 0 /* ArgumentCategory.Simple */) {
+                        return this._isNarrowingExpression(expression.d.leftExpr.d.args[0].d.valueExpr, expressionList, filterForNeverNarrowing, 
                         /* isComplexExpression */ true);
                     }
-                    const isLeftNarrowing = this._isNarrowingExpression(expression.leftExpression, expressionList, filterForNeverNarrowing, 
+                    const isLeftNarrowing = this._isNarrowingExpression(expression.d.leftExpr, expressionList, filterForNeverNarrowing, 
                     /* isComplexExpression */ true);
                     // Look for "X is Y" or "X is not Y".
                     // Look for X == <literal> or X != <literal>
@@ -2381,66 +2377,65 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                     return isLeftNarrowing;
                 }
                 // Look for len(X) < <literal>, len(X) <= <literal>, len(X) > <literal>, len(X) >= <literal>.
-                if (expression.rightExpression.nodeType === 40 /* ParseNodeType.Number */ &&
-                    expression.rightExpression.isInteger) {
-                    if (expression.operator === 20 /* OperatorType.LessThan */ ||
-                        expression.operator === 21 /* OperatorType.LessThanOrEqual */ ||
-                        expression.operator === 15 /* OperatorType.GreaterThan */ ||
-                        expression.operator === 16 /* OperatorType.GreaterThanOrEqual */) {
-                        const isLeftNarrowing = this._isNarrowingExpression(expression.leftExpression, expressionList, filterForNeverNarrowing, 
+                if (expression.d.rightExpr.nodeType === 40 /* ParseNodeType.Number */ && expression.d.rightExpr.d.isInteger) {
+                    if (expression.d.operator === 20 /* OperatorType.LessThan */ ||
+                        expression.d.operator === 21 /* OperatorType.LessThanOrEqual */ ||
+                        expression.d.operator === 15 /* OperatorType.GreaterThan */ ||
+                        expression.d.operator === 16 /* OperatorType.GreaterThanOrEqual */) {
+                        const isLeftNarrowing = this._isNarrowingExpression(expression.d.leftExpr, expressionList, filterForNeverNarrowing, 
                         /* isComplexExpression */ true);
                         return isLeftNarrowing;
                     }
                 }
                 // Look for "<string> in Y" or "<string> not in Y".
-                if (expression.operator === 41 /* OperatorType.In */ || expression.operator === 42 /* OperatorType.NotIn */) {
-                    if (expression.leftExpression.nodeType === 48 /* ParseNodeType.StringList */ &&
-                        this._isNarrowingExpression(expression.rightExpression, expressionList, filterForNeverNarrowing, 
+                if (expression.d.operator === 41 /* OperatorType.In */ || expression.d.operator === 42 /* OperatorType.NotIn */) {
+                    if (expression.d.leftExpr.nodeType === 48 /* ParseNodeType.StringList */ &&
+                        this._isNarrowingExpression(expression.d.rightExpr, expressionList, filterForNeverNarrowing, 
                         /* isComplexExpression */ true)) {
                         return true;
                     }
                 }
                 // Look for "X in Y" or "X not in Y".
-                if (expression.operator === 41 /* OperatorType.In */ || expression.operator === 42 /* OperatorType.NotIn */) {
-                    const isLeftNarrowable = this._isNarrowingExpression(expression.leftExpression, expressionList, filterForNeverNarrowing, 
+                if (expression.d.operator === 41 /* OperatorType.In */ || expression.d.operator === 42 /* OperatorType.NotIn */) {
+                    const isLeftNarrowable = this._isNarrowingExpression(expression.d.leftExpr, expressionList, filterForNeverNarrowing, 
                     /* isComplexExpression */ true);
-                    const isRightNarrowable = this._isNarrowingExpression(expression.rightExpression, expressionList, filterForNeverNarrowing, 
+                    const isRightNarrowable = this._isNarrowingExpression(expression.d.rightExpr, expressionList, filterForNeverNarrowing, 
                     /* isComplexExpression */ true);
                     return isLeftNarrowable || isRightNarrowable;
                 }
                 return false;
             }
             case 55 /* ParseNodeType.UnaryOperation */: {
-                return (expression.operator === 38 /* OperatorType.Not */ &&
-                    this._isNarrowingExpression(expression.expression, expressionList, filterForNeverNarrowing, 
+                return (expression.d.operator === 38 /* OperatorType.Not */ &&
+                    this._isNarrowingExpression(expression.d.expr, expressionList, filterForNeverNarrowing, 
                     /* isComplexExpression */ false));
             }
             case 5 /* ParseNodeType.AugmentedAssignment */: {
-                return this._isNarrowingExpression(expression.rightExpression, expressionList, filterForNeverNarrowing, 
+                return this._isNarrowingExpression(expression.d.rightExpr, expressionList, filterForNeverNarrowing, 
                 /* isComplexExpression */ true);
             }
             case 9 /* ParseNodeType.Call */: {
-                if (expression.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
-                    (expression.leftExpression.value === 'isinstance' ||
-                        expression.leftExpression.value === 'issubclass') &&
-                    expression.arguments.length === 2) {
-                    return this._isNarrowingExpression(expression.arguments[0].valueExpression, expressionList, filterForNeverNarrowing, 
+                if (expression.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ &&
+                    (expression.d.leftExpr.d.value === 'isinstance' ||
+                        expression.d.leftExpr.d.value === 'issubclass') &&
+                    expression.d.args.length === 2) {
+                    return this._isNarrowingExpression(expression.d.args[0].d.valueExpr, expressionList, filterForNeverNarrowing, 
                     /* isComplexExpression */ true);
                 }
-                if (expression.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
-                    expression.leftExpression.value === 'callable' &&
-                    expression.arguments.length === 1) {
-                    return this._isNarrowingExpression(expression.arguments[0].valueExpression, expressionList, filterForNeverNarrowing, 
+                if (expression.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ &&
+                    expression.d.leftExpr.d.value === 'callable' &&
+                    expression.d.args.length === 1) {
+                    return this._isNarrowingExpression(expression.d.args[0].d.valueExpr, expressionList, filterForNeverNarrowing, 
                     /* isComplexExpression */ true);
                 }
                 // Is this potentially a call to a user-defined type guard function?
-                if (expression.arguments.length >= 1) {
+                if (expression.d.args.length >= 1) {
                     // Never narrowing doesn't support type guards because they do not
                     // offer negative narrowing.
                     if (filterForNeverNarrowing) {
                         return false;
                     }
-                    return this._isNarrowingExpression(expression.arguments[0].valueExpression, expressionList, filterForNeverNarrowing, 
+                    return this._isNarrowingExpression(expression.d.args[0].d.valueExpr, expressionList, filterForNeverNarrowing, 
                     /* isComplexExpression */ true);
                 }
             }
@@ -2465,27 +2460,27 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 break;
             }
             case 52 /* ParseNodeType.Tuple */: {
-                target.expressions.forEach((expr) => {
+                target.d.items.forEach((expr) => {
                     this._createAssignmentTargetFlowNodes(expr, walkTargets, unbound);
                 });
                 break;
             }
             case 54 /* ParseNodeType.TypeAnnotation */: {
-                this._createAssignmentTargetFlowNodes(target.valueExpression, /* walkTargets */ false, unbound);
+                this._createAssignmentTargetFlowNodes(target.d.valueExpr, /* walkTargets */ false, unbound);
                 if (walkTargets) {
                     this.walk(target);
                 }
                 break;
             }
             case 56 /* ParseNodeType.Unpack */: {
-                this._createAssignmentTargetFlowNodes(target.expression, /* walkTargets */ false, unbound);
+                this._createAssignmentTargetFlowNodes(target.d.expr, /* walkTargets */ false, unbound);
                 if (walkTargets) {
                     this.walk(target);
                 }
                 break;
             }
             case 34 /* ParseNodeType.List */: {
-                target.entries.forEach((entry) => {
+                target.d.items.forEach((entry) => {
                     this._createAssignmentTargetFlowNodes(entry, walkTargets, unbound);
                 });
                 break;
@@ -2522,7 +2517,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     _createFlowAssignment(node, unbound = false) {
         let targetSymbolId = symbol_1.indeterminateSymbolId;
         if (node.nodeType === 38 /* ParseNodeType.Name */) {
-            const symbolWithScope = this._currentScope.lookUpSymbolRecursive(node.value);
+            const symbolWithScope = this._currentScope.lookUpSymbolRecursive(node.d.value);
             (0, debug_1.assert)(symbolWithScope !== undefined);
             targetSymbolId = symbolWithScope.symbol.id;
         }
@@ -2577,7 +2572,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 id: this._getUniqueFlowNodeId(),
                 node,
                 antecedent: this._currentFlowNode,
-                subjectExpression: node.subjectExpression,
+                subjectExpression: node.d.expr,
             };
             this._currentFlowNode = flowNode;
         }
@@ -2626,7 +2621,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         }
     }
     _bindNameToScope(scope, node, addedSymbols) {
-        return this._bindNameValueToScope(scope, node.value, addedSymbols);
+        return this._bindNameValueToScope(scope, node.d.value, addedSymbols);
     }
     _bindNameValueToScope(scope, name, addedSymbols) {
         // Is this name already bound to a scope other than the local one?
@@ -2685,23 +2680,23 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 break;
             }
             case 52 /* ParseNodeType.Tuple */: {
-                target.expressions.forEach((expr) => {
+                target.d.items.forEach((expr) => {
                     this._bindPossibleTupleNamedTarget(expr, addedSymbols);
                 });
                 break;
             }
             case 34 /* ParseNodeType.List */: {
-                target.entries.forEach((expr) => {
+                target.d.items.forEach((expr) => {
                     this._bindPossibleTupleNamedTarget(expr, addedSymbols);
                 });
                 break;
             }
             case 54 /* ParseNodeType.TypeAnnotation */: {
-                this._bindPossibleTupleNamedTarget(target.valueExpression, addedSymbols);
+                this._bindPossibleTupleNamedTarget(target.d.valueExpr, addedSymbols);
                 break;
             }
             case 56 /* ParseNodeType.Unpack */: {
-                this._bindPossibleTupleNamedTarget(target.expression, addedSymbols);
+                this._bindPossibleTupleNamedTarget(target.d.expr, addedSymbols);
                 break;
             }
         }
@@ -2760,21 +2755,21 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         switch (target.nodeType) {
             case 38 /* ParseNodeType.Name */: {
                 const name = target;
-                const symbolWithScope = this._currentScope.lookUpSymbolRecursive(name.value);
+                const symbolWithScope = this._currentScope.lookUpSymbolRecursive(name.d.value);
                 if (symbolWithScope && symbolWithScope.symbol) {
                     const declaration = {
                         type: 1 /* DeclarationType.Variable */,
                         node: target,
-                        isConstant: (0, symbolNameUtils_1.isConstantName)(target.value),
+                        isConstant: (0, symbolNameUtils_1.isConstantName)(target.d.value),
                         inferredTypeSource: source,
-                        isInferenceAllowedInPyTyped: this._isInferenceAllowedInPyTyped(name.value),
+                        isInferenceAllowedInPyTyped: this._isInferenceAllowedInPyTyped(name.d.value),
                         typeAliasName: isPossibleTypeAlias ? target : undefined,
                         uri: this._fileInfo.fileUri,
                         range: (0, positionUtils_1.convertTextRangeToRange)(name, this._fileInfo.lines),
                         moduleName: this._fileInfo.moduleName,
                         isInExceptSuite: this._isInExceptSuite,
                         docString: this._getVariableDocString(target),
-                        isExplicitBinding: this._currentScope.getBindingType(name.value) !== undefined,
+                        isExplicitBinding: this._currentScope.getBindingType(name.d.value) !== undefined,
                     };
                     symbolWithScope.symbol.addDeclaration(declaration);
                 }
@@ -2783,12 +2778,12 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             case 35 /* ParseNodeType.MemberAccess */: {
                 const memberAccessInfo = this._getMemberAccessInfo(target);
                 if (memberAccessInfo) {
-                    const name = target.memberName;
-                    let symbol = memberAccessInfo.classScope.lookUpSymbol(name.value);
+                    const name = target.d.member;
+                    let symbol = memberAccessInfo.classScope.lookUpSymbol(name.d.value);
                     if (!symbol) {
-                        symbol = memberAccessInfo.classScope.addSymbol(name.value, 1 /* SymbolFlags.InitiallyUnbound */);
+                        symbol = memberAccessInfo.classScope.addSymbol(name.d.value, 1 /* SymbolFlags.InitiallyUnbound */);
                         const honorPrivateNaming = this._fileInfo.diagnosticRuleSet.reportPrivateUsage !== 'none';
-                        if ((0, symbolNameUtils_1.isPrivateOrProtectedName)(name.value) && honorPrivateNaming) {
+                        if ((0, symbolNameUtils_1.isPrivateOrProtectedName)(name.d.value) && honorPrivateNaming) {
                             symbol.setIsPrivateMember();
                         }
                     }
@@ -2809,12 +2804,12 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                     }
                     const declaration = {
                         type: 1 /* DeclarationType.Variable */,
-                        node: target.memberName,
-                        isConstant: (0, symbolNameUtils_1.isConstantName)(name.value),
+                        node: target.d.member,
+                        isConstant: (0, symbolNameUtils_1.isConstantName)(name.d.value),
                         inferredTypeSource: source,
                         isDefinedByMemberAccess: true,
                         uri: this._fileInfo.fileUri,
-                        range: (0, positionUtils_1.convertTextRangeToRange)(target.memberName, this._fileInfo.lines),
+                        range: (0, positionUtils_1.convertTextRangeToRange)(target.d.member, this._fileInfo.lines),
                         moduleName: this._fileInfo.moduleName,
                         isInExceptSuite: this._isInExceptSuite,
                         docString: this._getVariableDocString(target),
@@ -2824,21 +2819,21 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 break;
             }
             case 52 /* ParseNodeType.Tuple */: {
-                target.expressions.forEach((expr) => {
+                target.d.items.forEach((expr) => {
                     this._addInferredTypeAssignmentForVariable(expr, source);
                 });
                 break;
             }
             case 54 /* ParseNodeType.TypeAnnotation */: {
-                this._addInferredTypeAssignmentForVariable(target.valueExpression, source);
+                this._addInferredTypeAssignmentForVariable(target.d.valueExpr, source);
                 break;
             }
             case 56 /* ParseNodeType.Unpack */: {
-                this._addInferredTypeAssignmentForVariable(target.expression, source);
+                this._addInferredTypeAssignmentForVariable(target.d.expr, source);
                 break;
             }
             case 34 /* ParseNodeType.List */: {
-                target.entries.forEach((entry) => {
+                target.d.items.forEach((entry) => {
                     this._addInferredTypeAssignmentForVariable(entry, source);
                 });
                 break;
@@ -2855,7 +2850,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         switch (target.nodeType) {
             case 38 /* ParseNodeType.Name */: {
                 const name = target;
-                const symbolWithScope = this._currentScope.lookUpSymbolRecursive(name.value);
+                const symbolWithScope = this._currentScope.lookUpSymbolRecursive(name.d.value);
                 if (symbolWithScope && symbolWithScope.symbol) {
                     const finalInfo = this._isAnnotationFinal(typeAnnotation);
                     let typeAnnotationNode = typeAnnotation;
@@ -2889,7 +2884,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                     const declaration = {
                         type: 1 /* DeclarationType.Variable */,
                         node: target,
-                        isConstant: (0, symbolNameUtils_1.isConstantName)(name.value),
+                        isConstant: (0, symbolNameUtils_1.isConstantName)(name.d.value),
                         isFinal: finalInfo.isFinal,
                         typeAliasName: target,
                         uri: this._fileInfo.fileUri,
@@ -2898,7 +2893,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                         moduleName: this._fileInfo.moduleName,
                         isInExceptSuite: this._isInExceptSuite,
                         docString: this._getVariableDocString(target),
-                        isExplicitBinding: this._currentScope.getBindingType(name.value) !== undefined,
+                        isExplicitBinding: this._currentScope.getBindingType(name.d.value) !== undefined,
                     };
                     symbolWithScope.symbol.addDeclaration(declaration);
                     if (isFinalAssignedInClassBody) {
@@ -2912,14 +2907,14 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                     }
                     // Look for an 'InitVar' either by itself or wrapped in an 'Annotated'.
                     if (typeAnnotation.nodeType === 27 /* ParseNodeType.Index */) {
-                        if (this._isDataclassesAnnotation(typeAnnotation.baseExpression, 'InitVar')) {
+                        if (this._isDataclassesAnnotation(typeAnnotation.d.leftExpr, 'InitVar')) {
                             symbolWithScope.symbol.setIsInitVar();
                         }
-                        else if (this._isTypingAnnotation(typeAnnotation.baseExpression, 'Annotated') &&
-                            typeAnnotation.items.length > 0) {
-                            const item0Expr = typeAnnotation.items[0].valueExpression;
+                        else if (this._isTypingAnnotation(typeAnnotation.d.leftExpr, 'Annotated') &&
+                            typeAnnotation.d.items.length > 0) {
+                            const item0Expr = typeAnnotation.d.items[0].d.valueExpr;
                             if (item0Expr.nodeType === 27 /* ParseNodeType.Index */ &&
-                                this._isDataclassesAnnotation(item0Expr.baseExpression, 'InitVar')) {
+                                this._isDataclassesAnnotation(item0Expr.d.leftExpr, 'InitVar')) {
                                 symbolWithScope.symbol.setIsInitVar();
                             }
                         }
@@ -2938,12 +2933,12 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 // or an instance of the current class.
                 const memberAccessInfo = this._getMemberAccessInfo(target);
                 if (memberAccessInfo) {
-                    const name = target.memberName;
-                    let symbol = memberAccessInfo.classScope.lookUpSymbol(name.value);
+                    const name = target.d.member;
+                    let symbol = memberAccessInfo.classScope.lookUpSymbol(name.d.value);
                     if (!symbol) {
-                        symbol = memberAccessInfo.classScope.addSymbol(name.value, 1 /* SymbolFlags.InitiallyUnbound */);
+                        symbol = memberAccessInfo.classScope.addSymbol(name.d.value, 1 /* SymbolFlags.InitiallyUnbound */);
                         const honorPrivateNaming = this._fileInfo.diagnosticRuleSet.reportPrivateUsage !== 'none';
-                        if ((0, symbolNameUtils_1.isPrivateOrProtectedName)(name.value) && honorPrivateNaming) {
+                        if ((0, symbolNameUtils_1.isPrivateOrProtectedName)(name.d.value) && honorPrivateNaming) {
                             symbol.setIsPrivateMember();
                         }
                     }
@@ -2956,13 +2951,13 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                     const finalInfo = this._isAnnotationFinal(typeAnnotation);
                     const declaration = {
                         type: 1 /* DeclarationType.Variable */,
-                        node: target.memberName,
-                        isConstant: (0, symbolNameUtils_1.isConstantName)(name.value),
+                        node: target.d.member,
+                        isConstant: (0, symbolNameUtils_1.isConstantName)(name.d.value),
                         isDefinedByMemberAccess: true,
                         isFinal: finalInfo.isFinal,
                         uri: this._fileInfo.fileUri,
                         typeAnnotationNode: finalInfo.isFinal && !finalInfo.finalTypeNode ? undefined : typeAnnotation,
-                        range: (0, positionUtils_1.convertTextRangeToRange)(target.memberName, this._fileInfo.lines),
+                        range: (0, positionUtils_1.convertTextRangeToRange)(target.d.member, this._fileInfo.lines),
                         moduleName: this._fileInfo.moduleName,
                         isInExceptSuite: this._isInExceptSuite,
                         docString: this._getVariableDocString(target),
@@ -2990,19 +2985,18 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     _isKnownAnnotation(typeAnnotation, name, importAliases, symbolAliases) {
         let annotationNode = typeAnnotation;
         // Is this a quoted annotation?
-        if (annotationNode.nodeType === 48 /* ParseNodeType.StringList */ && annotationNode.typeAnnotation) {
-            annotationNode = annotationNode.typeAnnotation;
+        if (annotationNode.nodeType === 48 /* ParseNodeType.StringList */ && annotationNode.d.annotation) {
+            annotationNode = annotationNode.d.annotation;
         }
         if (annotationNode.nodeType === 38 /* ParseNodeType.Name */) {
-            const alias = symbolAliases.get(annotationNode.value);
+            const alias = symbolAliases.get(annotationNode.d.value);
             if (alias === name) {
                 return true;
             }
         }
         else if (annotationNode.nodeType === 35 /* ParseNodeType.MemberAccess */) {
-            if (annotationNode.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
-                annotationNode.memberName.value === name) {
-                const baseName = annotationNode.leftExpression.value;
+            if (annotationNode.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ && annotationNode.d.member.d.value === name) {
+                const baseName = annotationNode.d.leftExpr.d.value;
                 return importAliases.some((alias) => alias === baseName);
             }
         }
@@ -3014,12 +3008,12 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             return undefined;
         }
         // A docstring can consist of multiple joined strings in a single expression.
-        const strings = docNode.strings;
+        const strings = docNode.d.strings;
         if (strings.length === 1) {
             // Common case.
-            return strings[0].value;
+            return strings[0].d.value;
         }
-        return strings.map((s) => s.value).join('');
+        return strings.map((s) => s.d.value).join('');
     }
     // Determines if the specified type annotation expression is a "Final".
     // It returns a value indicating whether the expression is a "Final"
@@ -3038,19 +3032,19 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 isFinal = true;
             }
             else if (typeAnnotation.nodeType === 27 /* ParseNodeType.Index */ &&
-                typeAnnotation.items.length > 0 &&
-                this._isTypingAnnotation(typeAnnotation.baseExpression, 'Annotated')) {
-                return this._isAnnotationFinal(typeAnnotation.items[0].valueExpression);
+                typeAnnotation.d.items.length > 0 &&
+                this._isTypingAnnotation(typeAnnotation.d.leftExpr, 'Annotated')) {
+                return this._isAnnotationFinal(typeAnnotation.d.items[0].d.valueExpr);
             }
-            else if (typeAnnotation.nodeType === 27 /* ParseNodeType.Index */ && typeAnnotation.items.length === 1) {
+            else if (typeAnnotation.nodeType === 27 /* ParseNodeType.Index */ && typeAnnotation.d.items.length === 1) {
                 // Recursively call to see if the base expression is "Final".
-                const finalInfo = this._isAnnotationFinal(typeAnnotation.baseExpression);
+                const finalInfo = this._isAnnotationFinal(typeAnnotation.d.leftExpr);
                 if (finalInfo.isFinal &&
-                    typeAnnotation.items[0].argumentCategory === 0 /* ArgumentCategory.Simple */ &&
-                    !typeAnnotation.items[0].name &&
-                    !typeAnnotation.trailingComma) {
+                    typeAnnotation.d.items[0].d.argCategory === 0 /* ArgumentCategory.Simple */ &&
+                    !typeAnnotation.d.items[0].d.name &&
+                    !typeAnnotation.d.trailingComma) {
                     isFinal = true;
-                    finalTypeNode = typeAnnotation.items[0].valueExpression;
+                    finalTypeNode = typeAnnotation.d.items[0].d.valueExpr;
                 }
             }
         }
@@ -3064,27 +3058,27 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         let classVarTypeNode;
         while (typeAnnotation) {
             // Is this a quoted annotation?
-            if (typeAnnotation.nodeType === 48 /* ParseNodeType.StringList */ && typeAnnotation.typeAnnotation) {
-                typeAnnotation = typeAnnotation.typeAnnotation;
+            if (typeAnnotation.nodeType === 48 /* ParseNodeType.StringList */ && typeAnnotation.d.annotation) {
+                typeAnnotation = typeAnnotation.d.annotation;
             }
             if (typeAnnotation.nodeType === 27 /* ParseNodeType.Index */ &&
-                typeAnnotation.items.length > 0 &&
-                this._isTypingAnnotation(typeAnnotation.baseExpression, 'Annotated')) {
-                typeAnnotation = typeAnnotation.items[0].valueExpression;
+                typeAnnotation.d.items.length > 0 &&
+                this._isTypingAnnotation(typeAnnotation.d.leftExpr, 'Annotated')) {
+                typeAnnotation = typeAnnotation.d.items[0].d.valueExpr;
             }
             else if (this._isTypingAnnotation(typeAnnotation, 'ClassVar')) {
                 isClassVar = true;
                 break;
             }
-            else if (typeAnnotation.nodeType === 27 /* ParseNodeType.Index */ && typeAnnotation.items.length === 1) {
+            else if (typeAnnotation.nodeType === 27 /* ParseNodeType.Index */ && typeAnnotation.d.items.length === 1) {
                 // Recursively call to see if the base expression is "ClassVar".
-                const finalInfo = this._isAnnotationClassVar(typeAnnotation.baseExpression);
+                const finalInfo = this._isAnnotationClassVar(typeAnnotation.d.leftExpr);
                 if (finalInfo.isClassVar &&
-                    typeAnnotation.items[0].argumentCategory === 0 /* ArgumentCategory.Simple */ &&
-                    !typeAnnotation.items[0].name &&
-                    !typeAnnotation.trailingComma) {
+                    typeAnnotation.d.items[0].d.argCategory === 0 /* ArgumentCategory.Simple */ &&
+                    !typeAnnotation.d.items[0].d.name &&
+                    !typeAnnotation.d.trailingComma) {
                     isClassVar = true;
-                    classVarTypeNode = typeAnnotation.items[0].valueExpression;
+                    classVarTypeNode = typeAnnotation.d.items[0].d.valueExpr;
                 }
                 break;
             }
@@ -3100,10 +3094,10 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     _getMemberAccessInfo(node) {
         // We handle only simple names on the left-hand side of the expression,
         // not calls, nested member accesses, index expressions, etc.
-        if (node.leftExpression.nodeType !== 38 /* ParseNodeType.Name */) {
+        if (node.d.leftExpr.nodeType !== 38 /* ParseNodeType.Name */) {
             return undefined;
         }
-        const leftSymbolName = node.leftExpression.value;
+        const leftSymbolName = node.d.leftExpr.d.value;
         // Make sure the expression is within a function (i.e. a method) that's
         // within a class definition.
         const methodNode = ParseTreeUtils.getEnclosingFunction(node);
@@ -3117,11 +3111,11 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         // Determine whether the left-hand side indicates a class or
         // instance member.
         let isInstanceMember = false;
-        if (methodNode.parameters.length < 1 || !methodNode.parameters[0].name) {
+        if (methodNode.d.params.length < 1 || !methodNode.d.params[0].d.name) {
             return undefined;
         }
-        const className = classNode.name.value;
-        const firstParamName = methodNode.parameters[0].name.value;
+        const className = classNode.d.name.d.value;
+        const firstParamName = methodNode.d.params[0].d.name.d.value;
         if (leftSymbolName === className) {
             isInstanceMember = false;
         }
@@ -3132,7 +3126,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             // To determine whether the first parameter of the method
             // refers to the class or the instance, we need to apply
             // some heuristics.
-            if (methodNode.name.value === '__new__') {
+            if (methodNode.d.name.d.value === '__new__') {
                 // The __new__ method is special. It acts as a classmethod even
                 // though it doesn't have a @classmethod decorator.
                 isInstanceMember = false;
@@ -3141,9 +3135,9 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 // Assume that it's an instance member unless we find
                 // a decorator that tells us otherwise.
                 isInstanceMember = true;
-                for (const decorator of methodNode.decorators) {
-                    if (decorator.expression.nodeType === 38 /* ParseNodeType.Name */) {
-                        const decoratorName = decorator.expression.value;
+                for (const decorator of methodNode.d.decorators) {
+                    if (decorator.d.expr.nodeType === 38 /* ParseNodeType.Name */) {
+                        const decoratorName = decorator.d.expr.d.value;
                         if (decoratorName === 'staticmethod') {
                             // A static method doesn't have a "self" or "cls" parameter.
                             return undefined;
@@ -3198,15 +3192,15 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             annotationNode = node;
         }
         else {
-            if (node.leftExpression.nodeType !== 54 /* ParseNodeType.TypeAnnotation */) {
+            if (node.d.leftExpr.nodeType !== 54 /* ParseNodeType.TypeAnnotation */) {
                 return false;
             }
-            annotationNode = node.leftExpression;
+            annotationNode = node.d.leftExpr;
         }
-        if (annotationNode.valueExpression.nodeType !== 38 /* ParseNodeType.Name */) {
+        if (annotationNode.d.valueExpr.nodeType !== 38 /* ParseNodeType.Name */) {
             return false;
         }
-        const assignedNameNode = annotationNode.valueExpression;
+        const assignedNameNode = annotationNode.d.valueExpr;
         const specialTypes = new Set([
             'Tuple',
             'Generic',
@@ -3231,7 +3225,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             'OrderedDict',
             'TypeIs',
         ]);
-        const assignedName = assignedNameNode.value;
+        const assignedName = assignedNameNode.d.value;
         if (!specialTypes.has(assignedName)) {
             return false;
         }
@@ -3243,7 +3237,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             moduleName: this._fileInfo.moduleName,
             isInExceptSuite: this._isInExceptSuite,
         };
-        const symbol = this._bindNameToScope(this._currentScope, annotationNode.valueExpression);
+        const symbol = this._bindNameToScope(this._currentScope, annotationNode.d.valueExpr);
         if (symbol) {
             symbol.addDeclaration(specialBuiltInClassDeclaration);
         }
@@ -3276,7 +3270,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 this._addSyntaxError(localize_1.LocMessage.yieldOutsideFunction(), node);
             }
         }
-        else if (functionNode.isAsync && node.nodeType === 61 /* ParseNodeType.YieldFrom */) {
+        else if (functionNode.d.isAsync && node.nodeType === 61 /* ParseNodeType.YieldFrom */) {
             // PEP 525 indicates that 'yield from' is not allowed in an
             // async function.
             this._addSyntaxError(localize_1.LocMessage.yieldFromOutsideAsync(), node);
@@ -3288,8 +3282,8 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             this._targetFunctionDeclaration.yieldStatements.push(node);
             this._targetFunctionDeclaration.isGenerator = true;
         }
-        if (node.expression) {
-            this.walk(node.expression);
+        if (node.d.expr) {
+            this.walk(node.d.expr);
         }
         AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
     }
@@ -3372,7 +3366,7 @@ class DummyScopeGenerator extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitClass(node) {
         const newScope = this._createNewScope(3 /* ScopeType.Class */, () => {
-            this.walk(node.suite);
+            this.walk(node.d.suite);
         });
         if (!AnalyzerNodeInfo.getScope(node)) {
             AnalyzerNodeInfo.setScope(node, newScope);
@@ -3381,7 +3375,7 @@ class DummyScopeGenerator extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitFunction(node) {
         const newScope = this._createNewScope(2 /* ScopeType.Function */, () => {
-            this.walk(node.suite);
+            this.walk(node.d.suite);
         });
         if (!AnalyzerNodeInfo.getScope(node)) {
             AnalyzerNodeInfo.setScope(node, newScope);