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

package/dist/analyzer/checker.js

@@ -105,7 +105,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (codeComplexity > typeEvaluator_1.maxCodeComplexity) {
             this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.codeTooComplexToAnalyze(), { start: 0, length: 0 });
         }
-        this._walkStatementsAndReportUnreachable(this._moduleNode.statements);
+        this._walkStatementsAndReportUnreachable(this._moduleNode.d.statements);
         // Mark symbols accessed by __all__ as accessed.
         const dunderAllInfo = AnalyzerNodeInfo.getDunderAllInfo(this._moduleNode);
         if (dunderAllInfo) {
@@ -128,11 +128,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
     }
     visitSuite(node) {
-        this._walkStatementsAndReportUnreachable(node.statements);
+        this._walkStatementsAndReportUnreachable(node.d.statements);
         return false;
     }
     visitStatementList(node) {
-        node.statements.forEach((statement) => {
+        node.d.statements.forEach((statement) => {
             if ((0, parseNodes_1.isExpressionNode)(statement)) {
                 // Evaluate the expression in case it wasn't otherwise evaluated
                 // through lazy analysis. This will mark referenced symbols as
@@ -145,27 +145,27 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitClass(node) {
         const classTypeResult = this._evaluator.getTypeOfClass(node);
-        if (node.typeParameters) {
-            this.walk(node.typeParameters);
+        if (node.d.typeParams) {
+            this.walk(node.d.typeParams);
         }
-        this.walk(node.suite);
-        this.walkMultiple(node.decorators);
-        this.walkMultiple(node.arguments);
+        this.walk(node.d.suite);
+        this.walkMultiple(node.d.decorators);
+        this.walkMultiple(node.d.arguments);
         if (classTypeResult) {
             // Protocol classes cannot derive from non-protocol classes.
             if (types_1.ClassType.isProtocolClass(classTypeResult.classType)) {
-                node.arguments.forEach((arg) => {
-                    if (!arg.name) {
-                        const baseClassType = this._evaluator.getType(arg.valueExpression);
+                node.d.arguments.forEach((arg) => {
+                    if (!arg.d.name) {
+                        const baseClassType = this._evaluator.getType(arg.d.valueExpr);
                         if (baseClassType &&
                             (0, types_1.isInstantiableClass)(baseClassType) &&
                             !types_1.ClassType.isBuiltIn(baseClassType, 'Protocol') &&
                             !types_1.ClassType.isBuiltIn(baseClassType, 'Generic')) {
                             if (!types_1.ClassType.isProtocolClass(baseClassType)) {
                                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.protocolBaseClass().format({
-                                    classType: classTypeResult.classType.details.name,
-                                    baseType: baseClassType.details.name,
-                                }), arg.valueExpression);
+                                    classType: classTypeResult.classType.shared.name,
+                                    baseType: baseClassType.shared.name,
+                                }), arg.d.valueExpr);
                             }
                         }
                     }
@@ -182,16 +182,16 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._validateBaseClassOverrides(classTypeResult.classType);
             this._validateTypedDictOverrides(classTypeResult.classType);
             this._validateOverloadDecoratorConsistency(classTypeResult.classType);
-            this._validateMultipleInheritanceBaseClasses(classTypeResult.classType, node.name);
-            this._validateMultipleInheritanceCompatibility(classTypeResult.classType, node.name);
-            this._validateConstructorConsistency(classTypeResult.classType, node.name);
+            this._validateMultipleInheritanceBaseClasses(classTypeResult.classType, node.d.name);
+            this._validateMultipleInheritanceCompatibility(classTypeResult.classType, node.d.name);
+            this._validateConstructorConsistency(classTypeResult.classType, node.d.name);
             this._validateFinalMemberOverrides(classTypeResult.classType);
             this._validateInstanceVariableInitialization(node, classTypeResult.classType);
             this._validateFinalClassNotAbstract(classTypeResult.classType, node);
-            this._validateDataClassPostInit(classTypeResult.classType, node);
+            this._validateDataClassPostInit(classTypeResult.classType);
             this._validateEnumMembers(classTypeResult.classType, node);
             if (types_1.ClassType.isTypedDictClass(classTypeResult.classType)) {
-                this._validateTypedDictClassSuite(node.suite);
+                this._validateTypedDictClassSuite(node.d.suite);
             }
             if (types_1.ClassType.isEnumClass(classTypeResult.classType)) {
                 this._validateEnumClassOverride(node, classTypeResult.classType);
@@ -202,13 +202,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return false;
     }
     visitFunction(node) {
-        var _a, _b;
-        if (node.typeParameters) {
-            this.walk(node.typeParameters);
+        var _a, _b, _c;
+        if (node.d.typeParams) {
+            this.walk(node.d.typeParams);
         }
         if (!this._fileInfo.diagnosticRuleSet.analyzeUnannotatedFunctions && !this._fileInfo.isStubFile) {
             if (ParseTreeUtils.isUnannotatedFunction(node)) {
-                this._evaluator.addInformation(localize_1.LocMessage.unannotatedFunctionSkipped().format({ name: node.name.value }), node.name);
+                this._evaluator.addInformation(localize_1.LocMessage.unannotatedFunctionSkipped().format({ name: node.d.name.d.value }), node.d.name);
             }
         }
         const functionTypeResult = this._evaluator.getTypeOfFunction(node);
@@ -220,41 +220,42 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const keywordNames = new Set();
             const paramDetails = (0, parameterUtils_1.getParameterListDetails)(functionTypeResult.functionType);
             // Report any unknown or missing parameter types.
-            node.parameters.forEach((param, index) => {
-                if (param.name) {
-                    if (param.category === 0 /* ParameterCategory.Simple */ && index >= paramDetails.positionOnlyParamCount) {
-                        keywordNames.add(param.name.value);
+            node.d.params.forEach((param, index) => {
+                var _a;
+                if (param.d.name) {
+                    if (param.d.category === 0 /* ParameterCategory.Simple */ && index >= paramDetails.positionOnlyParamCount) {
+                        keywordNames.add(param.d.name.d.value);
                     }
                     // Determine whether this is a P.args parameter.
-                    if (param.category === 1 /* ParameterCategory.ArgsList */) {
-                        const annotationExpr = param.typeAnnotation || param.typeAnnotationComment;
+                    if (param.d.category === 1 /* ParameterCategory.ArgsList */) {
+                        const annotationExpr = (_a = param.d.annotation) !== null && _a !== void 0 ? _a : param.d.annotationComment;
                         if (annotationExpr &&
                             annotationExpr.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
-                            annotationExpr.memberName.value === 'args') {
-                            const baseType = this._evaluator.getType(annotationExpr.leftExpression);
-                            if (baseType && (0, types_1.isTypeVar)(baseType) && baseType.details.isParamSpec) {
+                            annotationExpr.d.member.d.value === 'args') {
+                            const baseType = this._evaluator.getType(annotationExpr.d.leftExpr);
+                            if (baseType && (0, types_1.isTypeVar)(baseType) && baseType.shared.isParamSpec) {
                                 sawParamSpecArgs = true;
                             }
                         }
                     }
-                    else if (param.category === 2 /* ParameterCategory.KwargsDict */) {
+                    else if (param.d.category === 2 /* ParameterCategory.KwargsDict */) {
                         sawParamSpecArgs = false;
                     }
                 }
-                if (param.name && param.category === 0 /* ParameterCategory.Simple */ && sawParamSpecArgs) {
-                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.namedParamAfterParamSpecArgs().format({ name: param.name.value }), param.name);
+                if (param.d.name && param.d.category === 0 /* ParameterCategory.Simple */ && sawParamSpecArgs) {
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.namedParamAfterParamSpecArgs().format({ name: param.d.name.d.value }), param.d.name);
                 }
                 // Allow unknown and missing param types if the param is named '_'.
-                if (param.name && param.name.value !== '_') {
-                    const functionTypeParam = functionTypeResult.functionType.details.parameters.find((p) => { var _a; return p.name === ((_a = param.name) === null || _a === void 0 ? void 0 : _a.value); });
+                if (param.d.name && param.d.name.d.value !== '_') {
+                    const functionTypeParam = functionTypeResult.functionType.shared.parameters.find((p) => { var _a; return p.name === ((_a = param.d.name) === null || _a === void 0 ? void 0 : _a.d.value); });
                     if (functionTypeParam) {
                         const paramType = functionTypeParam.type;
                         if (this._fileInfo.diagnosticRuleSet.reportUnknownParameterType !== 'none') {
                             if ((0, types_1.isUnknown)(paramType) ||
                                 ((0, types_1.isTypeVar)(paramType) &&
-                                    paramType.details.isSynthesized &&
-                                    !paramType.details.isSynthesizedSelf)) {
-                                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.LocMessage.paramTypeUnknown().format({ paramName: param.name.value }), param.name);
+                                    paramType.shared.isSynthesized &&
+                                    !paramType.shared.isSynthesizedSelf)) {
+                                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.LocMessage.paramTypeUnknown().format({ paramName: param.d.name.d.value }), param.d.name);
                             }
                             else if ((0, typeUtils_1.isPartlyUnknown)(paramType)) {
                                 const diagAddendum = new diagnostic_1.DiagnosticAddendum();
@@ -262,33 +263,33 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                                     paramType: this._evaluator.printType(paramType, { expandTypeAlias: true }),
                                 }));
                                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.LocMessage.paramTypePartiallyUnknown().format({
-                                    paramName: param.name.value,
-                                }) + diagAddendum.getString(), param.name);
+                                    paramName: param.d.name.d.value,
+                                }) + diagAddendum.getString(), param.d.name);
                             }
                         }
                         let hasAnnotation = false;
-                        if (functionTypeParam.typeAnnotation) {
+                        if (types_1.FunctionParam.isTypeDeclared(functionTypeParam)) {
                             hasAnnotation = true;
                         }
                         else {
                             // See if this is a "self" and "cls" parameter. They are exempt from this rule.
-                            if ((0, types_1.isTypeVar)(paramType) && paramType.details.isSynthesizedSelf) {
+                            if ((0, types_1.isTypeVar)(paramType) && paramType.shared.isSynthesizedSelf) {
                                 hasAnnotation = true;
                             }
                         }
                         if (!hasAnnotation && this._fileInfo.diagnosticRuleSet.reportMissingParameterType !== 'none') {
-                            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportMissingParameterType, localize_1.LocMessage.paramAnnotationMissing().format({ name: param.name.value }), param.name);
+                            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportMissingParameterType, localize_1.LocMessage.paramAnnotationMissing().format({ name: param.d.name.d.value }), param.d.name);
                         }
                     }
                 }
             });
             // Verify that an unpacked TypedDict doesn't overlap any keyword parameters.
             if (paramDetails.hasUnpackedTypedDict) {
-                const kwargsIndex = functionTypeResult.functionType.details.parameters.length - 1;
+                const kwargsIndex = functionTypeResult.functionType.shared.parameters.length - 1;
                 const kwargsType = types_1.FunctionType.getEffectiveParameterType(functionTypeResult.functionType, kwargsIndex);
-                if ((0, types_1.isClass)(kwargsType) && kwargsType.details.typedDictEntries) {
+                if ((0, types_1.isClass)(kwargsType) && kwargsType.shared.typedDictEntries) {
                     const overlappingEntries = new Set();
-                    kwargsType.details.typedDictEntries.knownItems.forEach((_, name) => {
+                    kwargsType.shared.typedDictEntries.knownItems.forEach((_, name) => {
                         if (keywordNames.has(name)) {
                             overlappingEntries.add(name);
                         }
@@ -296,85 +297,89 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     if (overlappingEntries.size > 0) {
                         this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.overlappingKeywordArgs().format({
                             names: [...overlappingEntries.values()].join(', '),
-                        }), (_a = node.parameters[kwargsIndex].typeAnnotation) !== null && _a !== void 0 ? _a : node.parameters[kwargsIndex]);
+                        }), (_a = node.d.params[kwargsIndex].d.annotation) !== null && _a !== void 0 ? _a : node.d.params[kwargsIndex]);
                     }
                 }
             }
             // Check for invalid use of ParamSpec P.args and P.kwargs.
-            const paramSpecParams = functionTypeResult.functionType.details.parameters.filter((param) => {
-                if (param.typeAnnotation && (0, types_1.isTypeVar)(param.type) && (0, types_1.isParamSpec)(param.type)) {
-                    if (param.category !== 0 /* ParameterCategory.Simple */ && param.name && param.type.paramSpecAccess) {
+            const paramSpecParams = functionTypeResult.functionType.shared.parameters.filter((param) => {
+                if (types_1.FunctionParam.isTypeDeclared(param) && (0, types_1.isTypeVar)(param.type) && (0, types_1.isParamSpec)(param.type)) {
+                    if (param.category !== 0 /* ParameterCategory.Simple */ && param.name && param.type.priv.paramSpecAccess) {
                         return true;
                     }
                 }
                 return false;
             });
-            if (paramSpecParams.length === 1 && paramSpecParams[0].typeAnnotation) {
-                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramSpecArgsKwargsUsage(), paramSpecParams[0].typeAnnotation);
+            if (paramSpecParams.length === 1 && paramSpecParams[0].name) {
+                const paramNode = node.d.params.find((param) => { var _a; return ((_a = param.d.name) === null || _a === void 0 ? void 0 : _a.d.value) === paramSpecParams[0].name; });
+                const annotationNode = (_b = paramNode === null || paramNode === void 0 ? void 0 : paramNode.d.annotation) !== null && _b !== void 0 ? _b : paramNode === null || paramNode === void 0 ? void 0 : paramNode.d.annotationComment;
+                if (annotationNode) {
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramSpecArgsKwargsUsage(), annotationNode);
+                }
             }
             // If this is a stub, ensure that the return type is specified.
             if (this._fileInfo.isStubFile) {
-                const returnAnnotation = node.returnTypeAnnotation || ((_b = node.functionAnnotationComment) === null || _b === void 0 ? void 0 : _b.returnTypeAnnotation);
+                const returnAnnotation = node.d.returnAnnotation || ((_c = node.d.funcAnnotationComment) === null || _c === void 0 ? void 0 : _c.d.returnAnnotation);
                 if (!returnAnnotation) {
-                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.LocMessage.returnTypeUnknown(), node.name);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.LocMessage.returnTypeUnknown(), node.d.name);
                 }
             }
             if (containingClassNode) {
                 this._validateMethod(node, functionTypeResult.functionType, containingClassNode);
             }
         }
-        node.parameters.forEach((param, index) => {
-            if (param.defaultValue) {
-                this.walk(param.defaultValue);
+        node.d.params.forEach((param, index) => {
+            if (param.d.defaultValue) {
+                this.walk(param.d.defaultValue);
             }
-            if (param.typeAnnotation) {
-                this.walk(param.typeAnnotation);
+            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);
             }
             // Look for method parameters that are typed with TypeVars that have the wrong variance.
             if (functionTypeResult) {
-                const annotationNode = param.typeAnnotation || param.typeAnnotationComment;
-                if (annotationNode && index < functionTypeResult.functionType.details.parameters.length) {
-                    const paramType = functionTypeResult.functionType.details.parameters[index].type;
+                const annotationNode = param.d.annotation || param.d.annotationComment;
+                if (annotationNode && index < functionTypeResult.functionType.shared.parameters.length) {
+                    const paramType = functionTypeResult.functionType.shared.parameters[index].type;
                     const exemptMethods = ['__init__', '__new__'];
                     if (containingClassNode &&
                         (0, types_1.isTypeVar)(paramType) &&
-                        paramType.details.declaredVariance === 3 /* Variance.Covariant */ &&
-                        !paramType.details.isSynthesized &&
-                        !exemptMethods.some((name) => name === functionTypeResult.functionType.details.name)) {
+                        paramType.shared.declaredVariance === 3 /* Variance.Covariant */ &&
+                        !paramType.shared.isSynthesized &&
+                        !exemptMethods.some((name) => name === functionTypeResult.functionType.shared.name)) {
                         this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramTypeCovariant(), annotationNode);
                     }
                 }
             }
         });
-        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);
             if (this._fileInfo.diagnosticRuleSet.reportTypeCommentUsage !== 'none' &&
                 this._fileInfo.executionEnvironment.pythonVersion.isGreaterOrEqualTo(pythonVersion_1.pythonVersion3_5)) {
-                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportTypeCommentUsage, localize_1.LocMessage.typeCommentDeprecated(), node.functionAnnotationComment);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportTypeCommentUsage, localize_1.LocMessage.typeCommentDeprecated(), node.d.funcAnnotationComment);
             }
         }
-        this.walkMultiple(node.decorators);
-        node.parameters.forEach((param) => {
-            if (param.name) {
-                this.walk(param.name);
+        this.walkMultiple(node.d.decorators);
+        node.d.params.forEach((param) => {
+            if (param.d.name) {
+                this.walk(param.d.name);
             }
         });
         const codeComplexity = AnalyzerNodeInfo.getCodeFlowComplexity(node);
         const isTooComplexToAnalyze = codeComplexity > typeEvaluator_1.maxCodeComplexity;
         if (isPrintCodeComplexityEnabled) {
-            console.log(`Code complexity of function ${node.name.value} is ${codeComplexity.toString()}`);
+            console.log(`Code complexity of function ${node.d.name.d.value} is ${codeComplexity.toString()}`);
         }
         if (isTooComplexToAnalyze) {
-            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.codeTooComplexToAnalyze(), node.name);
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.codeTooComplexToAnalyze(), node.d.name);
         }
         else {
-            this.walk(node.suite);
+            this.walk(node.d.suite);
         }
         if (functionTypeResult) {
             // Validate that the function returns the declared type.
@@ -390,16 +395,16 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._reportDeprecatedClassProperty(node, functionTypeResult);
             // If this is not a method, @final is disallowed.
             if (!containingClassNode && types_1.FunctionType.isFinal(functionTypeResult.functionType)) {
-                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.finalNonMethod().format({ name: node.name.value }), node.name);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.finalNonMethod().format({ name: node.d.name.d.value }), node.d.name);
             }
         }
         // If we're at the module level within a stub file, report a diagnostic
         // if there is a '__getattr__' function defined when in strict mode.
         // This signifies an incomplete stub file that obscures type errors.
-        if (this._fileInfo.isStubFile && node.name.value === '__getattr__') {
+        if (this._fileInfo.isStubFile && node.d.name.d.value === '__getattr__') {
             const scope = (0, scopeUtils_1.getScopeForNode)(node);
             if ((scope === null || scope === void 0 ? void 0 : scope.type) === 4 /* ScopeType.Module */) {
-                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompleteStub, localize_1.LocMessage.stubUsesGetAttr(), node.name);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompleteStub, localize_1.LocMessage.stubUsesGetAttr(), node.d.name);
             }
         }
         this._scopedNodes.push(node);
@@ -426,29 +431,29 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     visitLambda(node) {
         this._evaluator.getType(node);
         // Walk the children.
-        this.walkMultiple([...node.parameters, node.expression]);
-        node.parameters.forEach((param) => {
-            if (param.name) {
-                const paramType = this._evaluator.getType(param.name);
+        this.walkMultiple([...node.d.params, node.d.expr]);
+        node.d.params.forEach((param) => {
+            if (param.d.name) {
+                const paramType = this._evaluator.getType(param.d.name);
                 if (paramType) {
                     if ((0, types_1.isUnknown)(paramType)) {
-                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownLambdaType, localize_1.LocMessage.paramTypeUnknown().format({ paramName: param.name.value }), param.name);
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownLambdaType, localize_1.LocMessage.paramTypeUnknown().format({ paramName: param.d.name.d.value }), param.d.name);
                     }
                     else if ((0, typeUtils_1.isPartlyUnknown)(paramType)) {
-                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownLambdaType, localize_1.LocMessage.paramTypePartiallyUnknown().format({ paramName: param.name.value }), param.name);
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownLambdaType, localize_1.LocMessage.paramTypePartiallyUnknown().format({ paramName: param.d.name.d.value }), param.d.name);
                     }
                 }
             }
         });
-        const returnType = this._evaluator.getType(node.expression);
+        const returnType = this._evaluator.getType(node.d.expr);
         if (returnType) {
             if ((0, types_1.isUnknown)(returnType)) {
-                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownLambdaType, localize_1.LocMessage.lambdaReturnTypeUnknown(), node.expression);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownLambdaType, localize_1.LocMessage.lambdaReturnTypeUnknown(), node.d.expr);
             }
             else if ((0, typeUtils_1.isPartlyUnknown)(returnType)) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownLambdaType, localize_1.LocMessage.lambdaReturnTypePartiallyUnknown().format({
                     returnType: this._evaluator.printType(returnType, { expandTypeAlias: true }),
-                }), node.expression);
+                }), node.d.expr);
             }
         }
         this._scopedNodes.push(node);
@@ -462,7 +467,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (this._fileInfo.diagnosticRuleSet.reportUnusedCallResult !== 'none' ||
             this._fileInfo.diagnosticRuleSet.reportUnusedCoroutine !== 'none') {
             if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 47 /* ParseNodeType.StatementList */) {
-                const isRevealTypeCall = node.leftExpression.nodeType === 38 /* ParseNodeType.Name */ && node.leftExpression.value === 'reveal_type';
+                const isRevealTypeCall = node.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ && node.d.leftExpr.d.value === 'reveal_type';
                 const returnType = this._evaluator.getType(node);
                 if (!isRevealTypeCall && returnType && this._isTypeValidForUnusedValueTest(returnType)) {
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnusedCallResult, localize_1.LocMessage.unusedCallResult().format({
@@ -479,8 +484,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     visitAwait(node) {
         var _a;
         if (this._fileInfo.diagnosticRuleSet.reportUnusedCallResult !== 'none') {
-            if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 47 /* ParseNodeType.StatementList */ &&
-                node.expression.nodeType === 9 /* ParseNodeType.Call */) {
+            if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 47 /* ParseNodeType.StatementList */ && node.d.expr.nodeType === 9 /* ParseNodeType.Call */) {
                 const returnType = this._evaluator.getType(node);
                 if (returnType && this._isTypeValidForUnusedValueTest(returnType)) {
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnusedCallResult, localize_1.LocMessage.unusedCallResult().format({
@@ -493,8 +497,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitFor(node) {
         this._evaluator.evaluateTypesForStatement(node);
-        if (node.typeComment) {
-            this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.annotationNotSupported(), node.typeComment);
+        if (node.d.typeComment) {
+            this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.annotationNotSupported(), node.d.typeComment);
         }
         return true;
     }
@@ -515,39 +519,39 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitComprehensionIf(node) {
-        this._validateConditionalIsBool(node.testExpression);
-        this._reportUnnecessaryConditionExpression(node.testExpression);
+        this._validateConditionalIsBool(node.d.testExpr);
+        this._reportUnnecessaryConditionExpression(node.d.testExpr);
         return true;
     }
     visitIf(node) {
-        this._validateConditionalIsBool(node.testExpression);
-        this._reportUnnecessaryConditionExpression(node.testExpression);
+        this._validateConditionalIsBool(node.d.testExpr);
+        this._reportUnnecessaryConditionExpression(node.d.testExpr);
         return true;
     }
     visitWhile(node) {
-        this._validateConditionalIsBool(node.testExpression);
-        this._reportUnnecessaryConditionExpression(node.testExpression);
+        this._validateConditionalIsBool(node.d.testExpr);
+        this._reportUnnecessaryConditionExpression(node.d.testExpr);
         return true;
     }
     visitWith(node) {
-        node.withItems.forEach((item) => {
+        node.d.withItems.forEach((item) => {
             this._evaluator.evaluateTypesForStatement(item);
         });
-        if (node.typeComment) {
-            this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.annotationNotSupported(), node.typeComment);
+        if (node.d.typeComment) {
+            this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.annotationNotSupported(), node.d.typeComment);
         }
         return true;
     }
     visitReturn(node) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f;
         let returnTypeResult;
         let returnType;
         const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(node);
-        const declaredReturnType = enclosingFunctionNode
+        let declaredReturnType = enclosingFunctionNode
             ? this._evaluator.getFunctionDeclaredReturnType(enclosingFunctionNode)
             : undefined;
-        if (node.returnExpression) {
-            returnTypeResult = (_a = this._evaluator.getTypeResult(node.returnExpression)) !== null && _a !== void 0 ? _a : { type: types_1.UnknownType.create() };
+        if (node.d.expr) {
+            returnTypeResult = (_a = this._evaluator.getTypeResult(node.d.expr)) !== null && _a !== void 0 ? _a : { type: types_1.UnknownType.create() };
         }
         else {
             // There is no return expression, so "None" is assumed.
@@ -555,16 +559,16 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         returnType = returnTypeResult.type;
         // If this type is a special form, use the special form instead.
-        if (returnType.specialForm) {
-            returnType = returnType.specialForm;
+        if ((_b = returnType.props) === null || _b === void 0 ? void 0 : _b.specialForm) {
+            returnType = returnType.props.specialForm;
         }
         // If the enclosing function is async and a generator, the return
         // statement is not allowed to have an argument. A syntax error occurs
         // at runtime in this case.
-        if ((enclosingFunctionNode === null || enclosingFunctionNode === void 0 ? void 0 : enclosingFunctionNode.isAsync) && node.returnExpression) {
+        if ((enclosingFunctionNode === null || enclosingFunctionNode === void 0 ? void 0 : enclosingFunctionNode.d.isAsync) && node.d.expr) {
             const functionDecl = AnalyzerNodeInfo.getDeclaration(enclosingFunctionNode);
             if ((functionDecl === null || functionDecl === void 0 ? void 0 : functionDecl.type) === 5 /* DeclarationType.Function */ && functionDecl.isGenerator) {
-                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.returnInAsyncGenerator(), node.returnExpression);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.returnInAsyncGenerator(), node.d.expr);
             }
         }
         if (this._evaluator.isNodeReachable(node, /* sourceNode */ undefined) && enclosingFunctionNode) {
@@ -573,10 +577,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.noReturnContainsReturn(), node);
                 }
                 else {
+                    const liveScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
+                    declaredReturnType = (0, typeUtils_1.updateTypeWithInternalTypeVars)(declaredReturnType, liveScopes);
                     let diagAddendum = new diagnostic_1.DiagnosticAddendum();
                     let returnTypeMatches = false;
                     if (this._evaluator.assignType(declaredReturnType, returnType, diagAddendum, 
-                    /* destTypeVarContext */ undefined, 
+                    /* destTypeVarContext */ new typeVarContext_1.TypeVarContext(), 
                     /* srcTypeVarContext */ undefined, 128 /* AssignTypeFlags.AllowBoolTypeGuard */)) {
                         returnTypeMatches = true;
                     }
@@ -584,11 +590,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         // See if the declared return type includes one or more constrained TypeVars. If so,
                         // try to narrow these TypeVars to a single type.
                         const uniqueTypeVars = (0, typeUtils_1.getTypeVarArgumentsRecursive)(declaredReturnType);
-                        if (uniqueTypeVars &&
-                            uniqueTypeVars.some((typeVar) => typeVar.details.constraints.length > 0)) {
+                        if (uniqueTypeVars && uniqueTypeVars.some((typeVar) => typeVar.shared.constraints.length > 0)) {
                             const typeVarContext = new typeVarContext_1.TypeVarContext();
                             for (const typeVar of uniqueTypeVars) {
-                                if (typeVar.details.constraints.length > 0) {
+                                if (typeVar.shared.constraints.length > 0) {
                                     const narrowedType = this._evaluator.narrowConstrainedTypeVar(node, typeVar);
                                     if (narrowedType) {
                                         typeVarContext.setTypeVarType(typeVar, narrowedType);
@@ -615,32 +620,32 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportReturnType, localize_1.LocMessage.returnTypeMismatch().format({
                             exprType: this._evaluator.printType(returnType),
                             returnType: this._evaluator.printType(declaredReturnType),
-                        }) + diagAddendum.getString(), (_b = node.returnExpression) !== null && _b !== void 0 ? _b : node, (_c = returnTypeResult.expectedTypeDiagAddendum) === null || _c === void 0 ? void 0 : _c.getEffectiveTextRange());
+                        }) + diagAddendum.getString(), (_c = node.d.expr) !== null && _c !== void 0 ? _c : node, (_d = returnTypeResult.expectedTypeDiagAddendum) === null || _d === void 0 ? void 0 : _d.getEffectiveTextRange());
                     }
                 }
             }
             if ((0, types_1.isUnknown)(returnType)) {
-                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.LocMessage.returnTypeUnknown(), (_d = node.returnExpression) !== null && _d !== void 0 ? _d : node);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.LocMessage.returnTypeUnknown(), (_e = node.d.expr) !== null && _e !== void 0 ? _e : node);
             }
             else if ((0, typeUtils_1.isPartlyUnknown)(returnType)) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.LocMessage.returnTypePartiallyUnknown().format({
                     returnType: this._evaluator.printType(returnType, { expandTypeAlias: true }),
-                }), (_e = node.returnExpression) !== null && _e !== void 0 ? _e : node);
+                }), (_f = node.d.expr) !== null && _f !== void 0 ? _f : node);
             }
         }
         return true;
     }
     visitYield(node) {
         var _a;
-        const yieldTypeResult = node.expression
-            ? this._evaluator.getTypeResult(node.expression)
+        const yieldTypeResult = node.d.expr
+            ? this._evaluator.getTypeResult(node.d.expr)
             : { type: this._evaluator.getNoneType() };
         this._validateYieldType(node, (_a = yieldTypeResult === null || yieldTypeResult === void 0 ? void 0 : yieldTypeResult.type) !== null && _a !== void 0 ? _a : types_1.UnknownType.create(), yieldTypeResult === null || yieldTypeResult === void 0 ? void 0 : yieldTypeResult.expectedTypeDiagAddendum);
         return true;
     }
     visitYieldFrom(node) {
         var _a, _b, _c, _d;
-        const yieldFromType = this._evaluator.getType(node.expression) || types_1.UnknownType.create();
+        const yieldFromType = this._evaluator.getType(node.d.expr) || types_1.UnknownType.create();
         let yieldType;
         let sendType;
         if ((0, types_1.isClassInstance)(yieldFromType) && types_1.ClassType.isBuiltIn(yieldFromType, 'Coroutine')) {
@@ -668,9 +673,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitRaise(node) {
         this._evaluator.verifyRaiseExceptionType(node);
-        if (node.valueExpression) {
+        if (node.d.valueExpression) {
             const baseExceptionType = this._evaluator.getBuiltInType(node, 'BaseException');
-            const exceptionType = this._evaluator.getType(node.valueExpression);
+            const exceptionType = this._evaluator.getType(node.d.valueExpression);
             // Validate that the argument of "raise" is an exception object or None.
             if (exceptionType && baseExceptionType && (0, types_1.isInstantiableClass)(baseExceptionType)) {
                 const diagAddendum = new diagnostic_1.DiagnosticAddendum();
@@ -692,36 +697,36 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                 });
                 if (!diagAddendum.isEmpty()) {
-                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.expectedExceptionObj() + diagAddendum.getString(), node.valueExpression);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.expectedExceptionObj() + diagAddendum.getString(), node.d.valueExpression);
                 }
             }
         }
         return true;
     }
     visitExcept(node) {
-        if (node.typeExpression) {
+        if (node.d.typeExpr) {
             this._evaluator.evaluateTypesForStatement(node);
-            const exceptionType = this._evaluator.getType(node.typeExpression);
+            const exceptionType = this._evaluator.getType(node.d.typeExpr);
             if (exceptionType) {
-                this._validateExceptionType(exceptionType, node.typeExpression, node.isExceptGroup);
+                this._validateExceptionType(exceptionType, node.d.typeExpr, node.d.isExceptGroup);
             }
         }
         return true;
     }
     visitAssert(node) {
-        if (node.exceptionExpression) {
-            this._evaluator.getType(node.exceptionExpression);
+        if (node.d.exceptionExpr) {
+            this._evaluator.getType(node.d.exceptionExpr);
         }
-        this._validateConditionalIsBool(node.testExpression);
+        this._validateConditionalIsBool(node.d.testExpr);
         // Specifically look for a common programming error where the two arguments
         // to an assert are enclosed in parens and interpreted as a two-element tuple.
         //   assert (x > 3, "bad value x")
-        const type = this._evaluator.getType(node.testExpression);
+        const type = this._evaluator.getType(node.d.testExpr);
         if (type && (0, types_1.isClassInstance)(type)) {
-            if ((0, typeUtils_1.isTupleClass)(type) && type.tupleTypeArguments) {
-                if (type.tupleTypeArguments.length > 0) {
+            if ((0, typeUtils_1.isTupleClass)(type) && type.priv.tupleTypeArguments) {
+                if (type.priv.tupleTypeArguments.length > 0) {
                     if (!(0, typeUtils_1.isUnboundedTupleClass)(type)) {
-                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportAssertAlwaysTrue, localize_1.LocMessage.assertAlwaysTrue(), node.testExpression);
+                        this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportAssertAlwaysTrue, localize_1.LocMessage.assertAlwaysTrue(), node.d.testExpr);
                     }
                 }
             }
@@ -730,23 +735,23 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitAssignment(node) {
         this._evaluator.evaluateTypesForStatement(node);
-        if (node.typeAnnotationComment) {
-            this._evaluator.getType(node.typeAnnotationComment);
+        if (node.d.annotationComment) {
+            this._evaluator.getType(node.d.annotationComment);
             if (this._fileInfo.diagnosticRuleSet.reportTypeCommentUsage !== 'none' &&
                 this._fileInfo.executionEnvironment.pythonVersion.isGreaterOrEqualTo(pythonVersion_1.pythonVersion3_6)) {
-                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportTypeCommentUsage, localize_1.LocMessage.typeCommentDeprecated(), node.typeAnnotationComment);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportTypeCommentUsage, localize_1.LocMessage.typeCommentDeprecated(), node.d.annotationComment);
             }
         }
         // If this isn't a class or global scope, explicit type aliases are not allowed.
-        if (node.leftExpression.nodeType === 54 /* ParseNodeType.TypeAnnotation */) {
-            const annotationType = this._evaluator.getTypeOfAnnotation(node.leftExpression.typeAnnotation);
+        if (node.d.leftExpr.nodeType === 54 /* ParseNodeType.TypeAnnotation */) {
+            const annotationType = this._evaluator.getTypeOfAnnotation(node.d.leftExpr.d.annotation);
             if ((0, types_1.isClassInstance)(annotationType) && types_1.ClassType.isBuiltIn(annotationType, 'TypeAlias')) {
                 const scope = (0, scopeUtils_1.getScopeForNode)(node);
                 if (scope) {
                     if (scope.type !== 3 /* ScopeType.Class */ &&
                         scope.type !== 4 /* ScopeType.Module */ &&
                         scope.type !== 5 /* ScopeType.Builtin */) {
-                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasNotInModuleOrClass(), node.leftExpression.typeAnnotation);
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasNotInModuleOrClass(), node.d.leftExpr.d.annotation);
                     }
                 }
             }
@@ -765,30 +770,32 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         this._evaluator.getType(node);
         // If the index is a literal integer, see if this is a tuple with
         // a known length and the integer value exceeds the length.
-        const baseType = this._evaluator.getType(node.baseExpression);
+        const baseType = this._evaluator.getType(node.d.leftExpr);
         if (baseType) {
             (0, typeUtils_1.doForEachSubtype)(baseType, (subtype) => {
                 const tupleType = (0, typeUtils_1.getSpecializedTupleType)(subtype);
-                if (!(0, types_1.isClassInstance)(subtype) || !(tupleType === null || tupleType === void 0 ? void 0 : tupleType.tupleTypeArguments) || (0, typeUtils_1.isUnboundedTupleClass)(tupleType)) {
+                if (!(0, types_1.isClassInstance)(subtype) ||
+                    !(tupleType === null || tupleType === void 0 ? void 0 : tupleType.priv.tupleTypeArguments) ||
+                    (0, typeUtils_1.isUnboundedTupleClass)(tupleType)) {
                     return;
                 }
-                const tupleLength = tupleType.tupleTypeArguments.length;
-                if (node.items.length !== 1 ||
-                    node.trailingComma ||
-                    node.items[0].argumentCategory !== 0 /* ArgumentCategory.Simple */ ||
-                    node.items[0].name) {
+                const tupleLength = tupleType.priv.tupleTypeArguments.length;
+                if (node.d.items.length !== 1 ||
+                    node.d.trailingComma ||
+                    node.d.items[0].d.argCategory !== 0 /* ArgumentCategory.Simple */ ||
+                    node.d.items[0].d.name) {
                     return;
                 }
-                const subscriptType = this._evaluator.getType(node.items[0].valueExpression);
+                const subscriptType = this._evaluator.getType(node.d.items[0].d.valueExpr);
                 if (!subscriptType ||
                     !(0, types_1.isClassInstance)(subscriptType) ||
                     !types_1.ClassType.isBuiltIn(subscriptType, 'int') ||
                     !(0, typeUtils_1.isLiteralType)(subscriptType) ||
-                    typeof subscriptType.literalValue !== 'number') {
+                    typeof subscriptType.priv.literalValue !== 'number') {
                     return;
                 }
-                if ((subscriptType.literalValue < 0 || subscriptType.literalValue < tupleLength) &&
-                    (subscriptType.literalValue >= 0 || subscriptType.literalValue + tupleLength >= 0)) {
+                if ((subscriptType.priv.literalValue < 0 || subscriptType.priv.literalValue < tupleLength) &&
+                    (subscriptType.priv.literalValue >= 0 || subscriptType.priv.literalValue + tupleLength >= 0)) {
                     return;
                 }
                 // This can be an expensive check, so we save it for the end once we
@@ -797,7 +804,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     return;
                 }
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.tupleIndexOutOfRange().format({
-                    index: subscriptType.literalValue,
+                    index: subscriptType.priv.literalValue,
                     type: this._evaluator.printType(subtype),
                 }), node);
             });
@@ -805,23 +812,23 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitBinaryOperation(node) {
-        if (node.operator === 36 /* OperatorType.And */ || node.operator === 37 /* OperatorType.Or */) {
-            this._validateConditionalIsBool(node.leftExpression);
-            this._validateConditionalIsBool(node.rightExpression);
+        if (node.d.operator === 36 /* OperatorType.And */ || node.d.operator === 37 /* OperatorType.Or */) {
+            this._validateConditionalIsBool(node.d.leftExpr);
+            this._validateConditionalIsBool(node.d.rightExpr);
         }
-        if (node.operator === 12 /* OperatorType.Equals */ || node.operator === 28 /* OperatorType.NotEquals */) {
+        if (node.d.operator === 12 /* OperatorType.Equals */ || node.d.operator === 28 /* OperatorType.NotEquals */) {
             // Don't apply this rule if it's within an assert.
             if (!ParseTreeUtils.isWithinAssertExpression(node)) {
                 this._validateComparisonTypes(node);
             }
         }
-        else if (node.operator === 39 /* OperatorType.Is */ || node.operator === 40 /* OperatorType.IsNot */) {
+        else if (node.d.operator === 39 /* OperatorType.Is */ || node.d.operator === 40 /* OperatorType.IsNot */) {
             // Don't apply this rule if it's within an assert.
             if (!ParseTreeUtils.isWithinAssertExpression(node)) {
                 this._validateComparisonTypesForIsOperator(node);
             }
         }
-        else if (node.operator === 41 /* OperatorType.In */ || node.operator === 42 /* OperatorType.NotIn */) {
+        else if (node.d.operator === 41 /* OperatorType.In */ || node.d.operator === 42 /* OperatorType.NotIn */) {
             // Don't apply this rule if it's within an assert.
             if (!ParseTreeUtils.isWithinAssertExpression(node)) {
                 this._validateContainmentTypes(node);
@@ -843,16 +850,16 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitUnaryOperation(node) {
-        if (node.operator === 38 /* OperatorType.Not */) {
-            this._validateConditionalIsBool(node.expression);
+        if (node.d.operator === 38 /* OperatorType.Not */) {
+            this._validateConditionalIsBool(node.d.expr);
         }
         this._evaluator.getType(node);
         return true;
     }
     visitTernary(node) {
         this._evaluator.getType(node);
-        this._validateConditionalIsBool(node.testExpression);
-        this._reportUnnecessaryConditionExpression(node.testExpression);
+        this._validateConditionalIsBool(node.d.testExpr);
+        this._reportUnnecessaryConditionExpression(node.d.testExpr);
         return true;
     }
     visitStringList(node) {
@@ -869,8 +876,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 curNode = curNode.parent;
             }
         }
-        for (const stringNode of node.strings) {
-            const stringTokens = stringNode.nodeType === 49 /* ParseNodeType.String */ ? [stringNode.token] : stringNode.middleTokens;
+        for (const stringNode of node.d.strings) {
+            const stringTokens = stringNode.nodeType === 49 /* ParseNodeType.String */ ? [stringNode.d.token] : stringNode.d.middleTokens;
             stringTokens.forEach((token) => {
                 const unescapedResult = (0, stringTokenUtils_1.getUnescapedString)(token);
                 let start = token.start;
@@ -894,31 +901,32 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // used the same quote scheme within an f-string.
             if (fStringContainers.length > 0) {
                 const quoteTypeMask = 1 /* StringTokenFlags.SingleQuote */ | 2 /* StringTokenFlags.DoubleQuote */ | 4 /* StringTokenFlags.Triplicate */;
-                if (fStringContainers.some((fStringContainer) => (fStringContainer.token.flags & quoteTypeMask) === (stringNode.token.flags & quoteTypeMask))) {
+                if (fStringContainers.some((fStringContainer) => (fStringContainer.d.token.flags & quoteTypeMask) ===
+                    (stringNode.d.token.flags & quoteTypeMask))) {
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.formatStringNestedQuote(), stringNode);
                 }
             }
         }
-        if (node.typeAnnotation) {
+        if (node.d.annotation) {
             this._evaluator.getType(node);
         }
-        if (node.strings.length > 1 && !node.isParenthesized) {
+        if (node.d.strings.length > 1 && !node.d.hasParens) {
             this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportImplicitStringConcatenation, localize_1.LocMessage.implicitStringConcat(), node);
         }
         return true;
     }
     visitFormatString(node) {
-        node.fieldExpressions.forEach((expr) => {
+        node.d.fieldExprs.forEach((expr) => {
             this._evaluator.getType(expr);
         });
-        node.formatExpressions.forEach((expr) => {
+        node.d.formatExprs.forEach((expr) => {
             this._evaluator.getType(expr);
         });
         return true;
     }
     visitGlobal(node) {
         this._suppressUnboundCheck(() => {
-            node.nameList.forEach((name) => {
+            node.d.targets.forEach((name) => {
                 this._evaluator.getType(name);
                 this.walk(name);
             });
@@ -927,7 +935,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitNonlocal(node) {
         this._suppressUnboundCheck(() => {
-            node.nameList.forEach((name) => {
+            node.d.targets.forEach((name) => {
                 this._evaluator.getType(name);
                 this.walk(name);
             });
@@ -947,7 +955,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitDel(node) {
-        node.expressions.forEach((expr) => {
+        node.d.targets.forEach((expr) => {
             this._evaluator.verifyDeleteExpression(expr);
             this.walk(expr);
         });
@@ -957,14 +965,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         var _a;
         const typeResult = this._evaluator.getTypeResult(node);
         const type = (_a = typeResult === null || typeResult === void 0 ? void 0 : typeResult.type) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
-        const leftExprType = this._evaluator.getType(node.leftExpression);
-        this._reportDeprecatedUseForType(node.memberName, type, leftExprType && (0, types_1.isModule)(leftExprType) && leftExprType.moduleName === 'typing');
+        const leftExprType = this._evaluator.getType(node.d.leftExpr);
+        this._reportDeprecatedUseForType(node.d.member, type, leftExprType && (0, types_1.isModule)(leftExprType) && leftExprType.priv.moduleName === 'typing');
         if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.memberAccessDeprecationInfo) {
-            this._reportDeprecatedUseForMemberAccess(node.memberName, typeResult.memberAccessDeprecationInfo);
+            this._reportDeprecatedUseForMemberAccess(node.d.member, typeResult.memberAccessDeprecationInfo);
         }
-        this._conditionallyReportPrivateUsage(node.memberName);
+        this._conditionallyReportPrivateUsage(node.d.member);
         // Walk the leftExpression but not the memberName.
-        this.walk(node.leftExpression);
+        this.walk(node.d.leftExpr);
         return false;
     }
     visitImportAs(node) {
@@ -974,27 +982,27 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitImportFrom(node) {
         // Verify that any "__future__" import occurs at the top of the file.
-        if (node.module.leadingDots === 0 &&
-            node.module.nameParts.length === 1 &&
-            node.module.nameParts[0].value === '__future__') {
+        if (node.d.module.d.leadingDots === 0 &&
+            node.d.module.d.nameParts.length === 1 &&
+            node.d.module.d.nameParts[0].d.value === '__future__') {
             if (!ParseTreeUtils.isValidLocationForFutureImport(node)) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.futureImportLocationNotAllowed(), node);
             }
         }
         this._conditionallyReportShadowedImport(node);
-        if (!node.isWildcardImport) {
-            node.imports.forEach((importAs) => {
+        if (!node.d.isWildcardImport) {
+            node.d.imports.forEach((importAs) => {
                 this._evaluator.evaluateTypesForStatement(importAs);
             });
         }
         else {
             this._evaluator.evaluateTypesForStatement(node);
-            const importInfo = AnalyzerNodeInfo.getImportInfo(node.module);
+            const importInfo = AnalyzerNodeInfo.getImportInfo(node.d.module);
             if (importInfo &&
                 importInfo.isImportFound &&
                 importInfo.importType !== 2 /* ImportType.Local */ &&
                 !this._fileInfo.isStubFile) {
-                this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportWildcardImportFromLibrary, localize_1.LocMessage.wildcardLibraryImport(), node.wildcardToken || node);
+                this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportWildcardImportFromLibrary, localize_1.LocMessage.wildcardLibraryImport(), node.d.wildcardToken || node);
             }
         }
         return true;
@@ -1004,7 +1012,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (this._fileInfo.isStubFile) {
             return false;
         }
-        const decls = this._evaluator.getDeclarationsForNameNode(node.name);
+        const decls = this._evaluator.getDeclarationsForNameNode(node.d.name);
         if (!decls) {
             return false;
         }
@@ -1022,19 +1030,19 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (!importResult) {
                 continue;
             }
-            this._addMissingModuleSourceDiagnosticIfNeeded(importResult, node.name);
+            this._addMissingModuleSourceDiagnosticIfNeeded(importResult, node.d.name);
             break;
         }
         let isImportFromTyping = false;
         if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 25 /* ParseNodeType.ImportFrom */) {
-            if (node.parent.module.leadingDots === 0 && node.parent.module.nameParts.length === 1) {
-                if (node.parent.module.nameParts[0].value === 'typing') {
+            if (node.parent.d.module.d.leadingDots === 0 && node.parent.d.module.d.nameParts.length === 1) {
+                if (node.parent.d.module.d.nameParts[0].d.value === 'typing') {
                     isImportFromTyping = true;
                 }
             }
         }
-        const type = this._evaluator.getType((_b = node.alias) !== null && _b !== void 0 ? _b : node.name);
-        this._reportDeprecatedUseForType(node.name, type, isImportFromTyping);
+        const type = this._evaluator.getType((_b = node.d.alias) !== null && _b !== void 0 ? _b : node.d.name);
+        this._reportDeprecatedUseForType(node.d.name, type, isImportFromTyping);
         return false;
     }
     visitModuleName(node) {
@@ -1063,14 +1071,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
             if (typeVarScopeNode.nodeType === 10 /* ParseNodeType.Class */) {
                 const classType = (_c = this._evaluator.getTypeOfClass(typeVarScopeNode)) === null || _c === void 0 ? void 0 : _c.classType;
-                if (classType === null || classType === void 0 ? void 0 : classType.details.typeParameters.some((param) => param.details.name === node.name.value)) {
+                if (classType === null || classType === void 0 ? void 0 : classType.shared.typeParameters.some((param) => param.shared.name === node.d.name.d.value)) {
                     foundDuplicate = true;
                     break;
                 }
             }
             else if (typeVarScopeNode.nodeType === 31 /* ParseNodeType.Function */) {
                 const functionType = (_d = this._evaluator.getTypeOfFunction(typeVarScopeNode)) === null || _d === void 0 ? void 0 : _d.functionType;
-                if (functionType === null || functionType === void 0 ? void 0 : functionType.details.typeParameters.some((param) => param.details.name === node.name.value)) {
+                if (functionType === null || functionType === void 0 ? void 0 : functionType.shared.typeParameters.some((param) => param.shared.name === node.d.name.d.value)) {
                     foundDuplicate = true;
                     break;
                 }
@@ -1078,7 +1086,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             curNode = typeVarScopeNode.parent;
         }
         if (foundDuplicate) {
-            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarUsedByOuterScope().format({ name: node.name.value }), node.name);
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarUsedByOuterScope().format({ name: node.d.name.d.value }), node.d.name);
         }
         return false;
     }
@@ -1086,25 +1094,25 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const scope = (0, scopeUtils_1.getScopeForNode)(node);
         if (scope) {
             if (scope.type !== 3 /* ScopeType.Class */ && scope.type !== 4 /* ScopeType.Module */ && scope.type !== 5 /* ScopeType.Builtin */) {
-                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasStatementBadScope(), node.name);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasStatementBadScope(), node.d.name);
             }
         }
         return true;
     }
     visitTypeAnnotation(node) {
-        this._evaluator.getType(node.typeAnnotation);
+        this._evaluator.getType(node.d.annotation);
         return true;
     }
     visitMatch(node) {
-        this._evaluator.getType(node.subjectExpression);
+        this._evaluator.getType(node.d.expr);
         this._validateExhaustiveMatch(node);
         return true;
     }
     visitCase(node) {
-        if (node.guardExpression) {
-            this._validateConditionalIsBool(node.guardExpression);
+        if (node.d.guardExpr) {
+            this._validateConditionalIsBool(node.d.guardExpr);
         }
-        this._evaluator.evaluateTypesForStatement(node.pattern);
+        this._evaluator.evaluateTypesForStatement(node.d.pattern);
         return true;
     }
     visitPatternClass(node) {
@@ -1118,17 +1126,17 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     visitError(node) {
         // Get the type of the child so it's available to
         // the completion provider.
-        if (node.child) {
-            this._evaluator.getType(node.child);
+        if (node.d.child) {
+            this._evaluator.getType(node.d.child);
         }
         // Don't explore further.
         return false;
     }
     _getImportResult(node, uri) {
         const execEnv = this._importResolver.getConfigOptions().findExecEnvironment(uri);
-        const moduleNameNode = node.parent.module;
+        const moduleNameNode = node.parent.d.module;
         // Handle both absolute and relative imports.
-        const moduleName = moduleNameNode.leadingDots === 0
+        const moduleName = moduleNameNode.d.leadingDots === 0
             ? this._importResolver.getModuleNameForImport(uri, execEnv).moduleName
             : (0, importStatementUtils_1.getRelativeModuleName)(this._importResolver.fileSystem, this._fileInfo.fileUri, uri, this._importResolver.getConfigOptions());
         if (!moduleName) {
@@ -1190,15 +1198,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     _reportUnnecessaryConditionExpression(expression) {
         if (expression.nodeType === 7 /* ParseNodeType.BinaryOperation */) {
-            if (expression.operator === 36 /* OperatorType.And */ || expression.operator === 37 /* OperatorType.Or */) {
-                this._reportUnnecessaryConditionExpression(expression.leftExpression);
-                this._reportUnnecessaryConditionExpression(expression.rightExpression);
+            if (expression.d.operator === 36 /* OperatorType.And */ || expression.d.operator === 37 /* OperatorType.Or */) {
+                this._reportUnnecessaryConditionExpression(expression.d.leftExpr);
+                this._reportUnnecessaryConditionExpression(expression.d.rightExpr);
             }
             return;
         }
         else if (expression.nodeType === 55 /* ParseNodeType.UnaryOperation */) {
-            if (expression.operator === 38 /* OperatorType.Not */) {
-                this._reportUnnecessaryConditionExpression(expression.expression);
+            if (expression.d.operator === 38 /* OperatorType.Not */) {
+                this._reportUnnecessaryConditionExpression(expression.d.expr);
             }
             return;
         }
@@ -1242,16 +1250,16 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             node.nodeType === 45 /* ParseNodeType.Set */ ||
             node.nodeType === 18 /* ParseNodeType.Dictionary */) {
             // Exclude comprehensions.
-            if (!node.entries.some((entry) => entry.nodeType === 11 /* ParseNodeType.Comprehension */)) {
+            if (!node.d.items.some((entry) => entry.nodeType === 11 /* ParseNodeType.Comprehension */)) {
                 reportAsUnused = true;
             }
         }
         if (reportAsUnused &&
             this._fileInfo.ipythonMode === sourceFile_1.IPythonMode.CellDocs &&
             ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 47 /* ParseNodeType.StatementList */ &&
-            node.parent.statements[node.parent.statements.length - 1] === node &&
+            node.parent.d.statements[node.parent.d.statements.length - 1] === node &&
             ((_b = node.parent.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 36 /* ParseNodeType.Module */ &&
-            node.parent.parent.statements[node.parent.parent.statements.length - 1] === node.parent) {
+            node.parent.parent.d.statements[node.parent.parent.d.statements.length - 1] === node.parent) {
             // Exclude an expression at the end of a notebook cell, as that is treated as
             // the cell's value.
             reportAsUnused = false;
@@ -1274,7 +1282,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 type: this._evaluator.printType(narrowedTypeResult.type),
             }));
             diagAddendum.addMessage(localize_1.LocAddendum.matchIsNotExhaustiveHint());
-            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportMatchNotExhaustive, localize_1.LocMessage.matchIsNotExhaustive() + diagAddendum.getString(), node.subjectExpression);
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportMatchNotExhaustive, localize_1.LocMessage.matchIsNotExhaustive() + diagAddendum.getString(), node.d.expr);
         }
     }
     _suppressUnboundCheck(callback) {
@@ -1295,24 +1303,24 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
     }
     _validateStandardCollectionInstantiation(node) {
-        const leftType = this._evaluator.getType(node.leftExpression);
+        const leftType = this._evaluator.getType(node.d.leftExpr);
         if (leftType &&
             (0, types_1.isInstantiableClass)(leftType) &&
             types_1.ClassType.isBuiltIn(leftType) &&
-            !leftType.includeSubclasses &&
-            leftType.aliasName) {
+            !leftType.priv.includeSubclasses &&
+            leftType.priv.aliasName) {
             const nonInstantiable = ['List', 'Set', 'Dict', 'Tuple'];
-            if (nonInstantiable.some((name) => name === leftType.aliasName)) {
+            if (nonInstantiable.some((name) => name === leftType.priv.aliasName)) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.collectionAliasInstantiation().format({
-                    type: leftType.aliasName,
-                    alias: leftType.details.name,
-                }), node.leftExpression);
+                    type: leftType.priv.aliasName,
+                    alias: leftType.shared.name,
+                }), node.d.leftExpr);
             }
         }
     }
     _validateContainmentTypes(node) {
-        const leftType = this._evaluator.getType(node.leftExpression);
-        const containerType = this._evaluator.getType(node.rightExpression);
+        const leftType = this._evaluator.getType(node.d.leftExpr);
+        const containerType = this._evaluator.getType(node.d.rightExpr);
         if (!leftType || !containerType) {
             return;
         }
@@ -1327,7 +1335,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const narrowedType = (0, typeGuards_1.narrowTypeForContainerElementType)(this._evaluator, leftType, this._evaluator.makeTopLevelTypeVarsConcrete(elementType));
         if ((0, types_1.isNever)(narrowedType)) {
             const getMessage = () => {
-                return node.operator === 41 /* OperatorType.In */
+                return node.d.operator === 41 /* OperatorType.In */
                     ? localize_1.LocMessage.containmentAlwaysFalse()
                     : localize_1.LocMessage.containmentAlwaysTrue();
             };
@@ -1340,11 +1348,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // Determines whether the types of the two operands for an "is" or "is not"
     // operation have overlapping types.
     _validateComparisonTypesForIsOperator(node) {
-        const rightType = this._evaluator.getType(node.rightExpression);
+        const rightType = this._evaluator.getType(node.d.rightExpr);
         if (!rightType || !(0, typeUtils_1.isNoneInstance)(rightType)) {
             return;
         }
-        const leftType = this._evaluator.getType(node.leftExpression);
+        const leftType = this._evaluator.getType(node.d.leftExpr);
         if (!leftType) {
             return;
         }
@@ -1356,7 +1364,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         });
         const getMessage = () => {
-            return node.operator === 39 /* OperatorType.Is */
+            return node.d.operator === 39 /* OperatorType.Is */
                 ? localize_1.LocMessage.comparisonAlwaysFalse()
                 : localize_1.LocMessage.comparisonAlwaysTrue();
         };
@@ -1370,15 +1378,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // Determines whether the types of the two operands for an == or != operation
     // have overlapping types.
     _validateComparisonTypes(node) {
-        let rightExpression = node.rightExpression;
+        let rightExpression = node.d.rightExpr;
         // Check for chained comparisons.
         if (rightExpression.nodeType === 7 /* ParseNodeType.BinaryOperation */ &&
-            !rightExpression.parenthesized &&
-            ParseTreeUtils.operatorSupportsChaining(rightExpression.operator)) {
+            !rightExpression.d.hasParens &&
+            ParseTreeUtils.operatorSupportsChaining(rightExpression.d.operator)) {
             // Use the left side of the right expression for comparison purposes.
-            rightExpression = rightExpression.leftExpression;
+            rightExpression = rightExpression.d.leftExpr;
         }
-        const leftType = this._evaluator.getType(node.leftExpression);
+        const leftType = this._evaluator.getType(node.d.leftExpr);
         const rightType = this._evaluator.getType(rightExpression);
         if (!leftType || !rightType) {
             return;
@@ -1387,7 +1395,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         const getMessage = () => {
-            return node.operator === 12 /* OperatorType.Equals */
+            return node.d.operator === 12 /* OperatorType.Equals */
                 ? localize_1.LocMessage.comparisonAlwaysFalse()
                 : localize_1.LocMessage.comparisonAlwaysTrue();
         };
@@ -1471,7 +1479,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             }
             // Does the class have an operator overload for eq?
-            const metaclass = leftType.details.effectiveMetaclass;
+            const metaclass = leftType.shared.effectiveMetaclass;
             if (metaclass && (0, types_1.isClass)(metaclass)) {
                 if ((0, typeUtils_1.lookUpClassMember)(metaclass, '__eq__', 4 /* MemberAccessFlags.SkipObjectBaseClass */)) {
                     return true;
@@ -1518,19 +1526,19 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!types_1.FunctionType.isGenerator(functionType)) {
             return;
         }
-        const declaredReturnType = functionType.details.declaredReturnType;
+        const declaredReturnType = functionType.shared.declaredReturnType;
         if (!declaredReturnType) {
             return;
         }
         if ((0, types_1.isNever)(declaredReturnType)) {
             return;
         }
-        const functionDecl = functionType.details.declaration;
+        const functionDecl = functionType.shared.declaration;
         if (!functionDecl || !functionDecl.yieldStatements || functionDecl.yieldStatements.length === 0) {
             return;
         }
         let generatorType;
-        if (!node.isAsync &&
+        if (!node.d.isAsync &&
             (0, types_1.isClassInstance)(declaredReturnType) &&
             types_1.ClassType.isBuiltIn(declaredReturnType, 'AwaitableGenerator')) {
             // Handle the old-style (pre-await) generator case
@@ -1538,7 +1546,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             generatorType = this._evaluator.getTypingType(node, 'AwaitableGenerator');
         }
         else {
-            generatorType = this._evaluator.getTypingType(node, node.isAsync ? 'AsyncGenerator' : 'Generator');
+            generatorType = this._evaluator.getTypingType(node, node.d.isAsync ? 'AsyncGenerator' : 'Generator');
         }
         if (!generatorType || !(0, types_1.isInstantiableClass)(generatorType)) {
             return;
@@ -1547,11 +1555,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         /* isTypeArgumentExplicit */ true));
         const diagAddendum = new diagnostic_1.DiagnosticAddendum();
         if (!this._evaluator.assignType(declaredReturnType, specializedGenerator, diagAddendum)) {
-            const errorMessage = node.isAsync
+            const errorMessage = node.d.isAsync
                 ? localize_1.LocMessage.generatorAsyncReturnType()
                 : localize_1.LocMessage.generatorSyncReturnType();
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, errorMessage.format({ yieldType: this._evaluator.printType(types_1.AnyType.create()) }) +
-                diagAddendum.getString(), (_a = node.returnTypeAnnotation) !== null && _a !== void 0 ? _a : node.name);
+                diagAddendum.getString(), (_a = node.d.returnAnnotation) !== null && _a !== void 0 ? _a : node.d.name);
         }
     }
     // Determines whether the specified type is one that should trigger
@@ -1572,7 +1580,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let curParamNode;
         // Is this a constructor (an __init__ method) for a generic class?
         let constructorClass;
-        if (types_1.FunctionType.isInstanceMethod(type) && node.name.value === '__init__') {
+        if (types_1.FunctionType.isInstanceMethod(type) && node.d.name.d.value === '__init__') {
             const containingClassNode = ParseTreeUtils.getEnclosingClassOrFunction(node);
             if (containingClassNode && containingClassNode.nodeType === 10 /* ParseNodeType.Class */) {
                 const classType = this._evaluator.getTypeOfClass(containingClassNode);
@@ -1582,17 +1590,17 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
         const nameWalker = new ParseTreeUtils.NameNodeWalker((nameNode, subscriptIndex, baseExpression) => {
-            var _a, _b, _c, _d, _e, _f;
+            var _a, _b, _c, _d, _e, _f, _g;
             const nameType = this._evaluator.getType(nameNode);
             ``;
-            if (nameType && (0, types_1.isTypeVar)(nameType) && !nameType.details.isSynthesizedSelf) {
+            if (nameType && (0, types_1.isTypeVar)(nameType) && !nameType.shared.isSynthesizedSelf) {
                 // Does this name refer to a TypeVar that is scoped to this function?
-                if (nameType.scopeId === ParseTreeUtils.getScopeIdForNode(node)) {
+                if (nameType.priv.scopeId === ParseTreeUtils.getScopeIdForNode(node)) {
                     // We exempt constrained TypeVars, TypeVars that are type arguments of
                     // other types, and ParamSpecs. There are legitimate uses for singleton
                     // instances in these particular cases.
-                    let isExempt = nameType.details.constraints.length > 0 ||
-                        nameType.details.isDefaultExplicit ||
+                    let isExempt = nameType.shared.constraints.length > 0 ||
+                        nameType.shared.isDefaultExplicit ||
                         (exemptBoundTypeVar && subscriptIndex !== undefined) ||
                         (0, types_1.isParamSpec)(nameType);
                     if (!isExempt && baseExpression && subscriptIndex !== undefined) {
@@ -1600,22 +1608,21 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         // exempt it from the check because the type alias may repeat
                         // the TypeVar multiple times.
                         const baseType = this._evaluator.getType(baseExpression);
-                        if ((baseType === null || baseType === void 0 ? void 0 : baseType.typeAliasInfo) &&
-                            baseType.typeAliasInfo.typeParameters &&
-                            subscriptIndex < baseType.typeAliasInfo.typeParameters.length) {
+                        const aliasInfo = (_a = baseType === null || baseType === void 0 ? void 0 : baseType.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo;
+                        if ((aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeParameters) && subscriptIndex < aliasInfo.typeParameters.length) {
                             isExempt = true;
                         }
                     }
-                    const existingEntry = localTypeVarUsage.get(nameType.details.name);
-                    const isParamTypeWithEllipsisUsage = ((_a = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.defaultValue) === null || _a === void 0 ? void 0 : _a.nodeType) === 21 /* ParseNodeType.Ellipsis */;
+                    const existingEntry = localTypeVarUsage.get(nameType.shared.name);
+                    const isParamTypeWithEllipsisUsage = ((_b = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.d.defaultValue) === null || _b === void 0 ? void 0 : _b.nodeType) === 21 /* ParseNodeType.Ellipsis */;
                     if (!existingEntry) {
-                        localTypeVarUsage.set(nameType.details.name, {
+                        localTypeVarUsage.set(nameType.shared.name, {
                             nodes: [nameNode],
                             typeVar: nameType,
                             paramTypeUsageCount: curParamNode !== undefined ? 1 : 0,
                             paramTypeWithEllipsisUsageCount: isParamTypeWithEllipsisUsage ? 1 : 0,
                             returnTypeUsageCount: curParamNode === undefined ? 1 : 0,
-                            paramWithEllipsis: isParamTypeWithEllipsisUsage ? (_b = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.name) === null || _b === void 0 ? void 0 : _b.value : undefined,
+                            paramWithEllipsis: isParamTypeWithEllipsisUsage ? (_c = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.d.name) === null || _c === void 0 ? void 0 : _c.d.value : undefined,
                             isExempt,
                         });
                     }
@@ -1626,7 +1633,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             if (isParamTypeWithEllipsisUsage) {
                                 existingEntry.paramTypeWithEllipsisUsageCount += 1;
                                 if (!existingEntry.paramWithEllipsis) {
-                                    existingEntry.paramWithEllipsis = (_c = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.name) === null || _c === void 0 ? void 0 : _c.value;
+                                    existingEntry.paramWithEllipsis = (_d = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.d.name) === null || _d === void 0 ? void 0 : _d.d.value;
                                 }
                             }
                         }
@@ -1637,18 +1644,18 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 // Does this name refer to a TypeVar that is scoped to the class associated with
                 // this constructor method?
-                if (constructorClass && nameType.scopeId === constructorClass.details.typeVarScopeId) {
-                    const existingEntry = classTypeVarUsage.get(nameType.details.name);
-                    const isParamTypeWithEllipsisUsage = ((_d = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.defaultValue) === null || _d === void 0 ? void 0 : _d.nodeType) === 21 /* ParseNodeType.Ellipsis */;
-                    const isExempt = !!nameType.details.isDefaultExplicit;
+                if (constructorClass && nameType.priv.scopeId === constructorClass.shared.typeVarScopeId) {
+                    const existingEntry = classTypeVarUsage.get(nameType.shared.name);
+                    const isParamTypeWithEllipsisUsage = ((_e = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.d.defaultValue) === null || _e === void 0 ? void 0 : _e.nodeType) === 21 /* ParseNodeType.Ellipsis */;
+                    const isExempt = !!nameType.shared.isDefaultExplicit;
                     if (!existingEntry) {
-                        classTypeVarUsage.set(nameType.details.name, {
+                        classTypeVarUsage.set(nameType.shared.name, {
                             typeVar: nameType,
                             nodes: [nameNode],
                             paramTypeUsageCount: curParamNode !== undefined ? 1 : 0,
                             paramTypeWithEllipsisUsageCount: isParamTypeWithEllipsisUsage ? 1 : 0,
                             returnTypeUsageCount: 0,
-                            paramWithEllipsis: isParamTypeWithEllipsisUsage ? (_e = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.name) === null || _e === void 0 ? void 0 : _e.value : undefined,
+                            paramWithEllipsis: isParamTypeWithEllipsisUsage ? (_f = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.d.name) === null || _f === void 0 ? void 0 : _f.d.value : undefined,
                             isExempt,
                         });
                     }
@@ -1659,7 +1666,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             if (isParamTypeWithEllipsisUsage) {
                                 existingEntry.paramTypeWithEllipsisUsageCount += 1;
                                 if (!existingEntry.paramWithEllipsis) {
-                                    existingEntry.paramWithEllipsis = (_f = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.name) === null || _f === void 0 ? void 0 : _f.value;
+                                    existingEntry.paramWithEllipsis = (_g = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.d.name) === null || _g === void 0 ? void 0 : _g.d.value;
                                 }
                             }
                         }
@@ -1668,28 +1675,28 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         });
         // Find all of the local type variables in signature.
-        node.parameters.forEach((param) => {
-            const annotation = param.typeAnnotation || param.typeAnnotationComment;
+        node.d.params.forEach((param) => {
+            const annotation = param.d.annotation || param.d.annotationComment;
             if (annotation) {
                 curParamNode = param;
                 nameWalker.walk(annotation);
             }
         });
         curParamNode = undefined;
-        if (node.returnTypeAnnotation) {
+        if (node.d.returnAnnotation) {
             // Don't exempt the use of a bound TypeVar when used as a type argument
             // within a return type. This exemption applies only to input parameter
             // annotations.
             exemptBoundTypeVar = false;
-            nameWalker.walk(node.returnTypeAnnotation);
+            nameWalker.walk(node.d.returnAnnotation);
         }
-        if (node.functionAnnotationComment) {
-            node.functionAnnotationComment.paramTypeAnnotations.forEach((expr) => {
+        if (node.d.funcAnnotationComment) {
+            node.d.funcAnnotationComment.d.paramAnnotations.forEach((expr) => {
                 nameWalker.walk(expr);
             });
-            if (node.functionAnnotationComment.returnTypeAnnotation) {
+            if (node.d.funcAnnotationComment.d.returnAnnotation) {
                 exemptBoundTypeVar = false;
-                nameWalker.walk(node.functionAnnotationComment.returnTypeAnnotation);
+                nameWalker.walk(node.d.funcAnnotationComment.d.returnAnnotation);
             }
         }
         localTypeVarUsage.forEach((usage) => {
@@ -1697,11 +1704,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // Report error for local type variable that appears only once.
             if (usage.nodes.length === 1 && !usage.isExempt) {
                 let altTypeText;
-                if (usage.typeVar.details.isVariadic) {
+                if (usage.typeVar.shared.isVariadic) {
                     altTypeText = '"tuple[object, ...]"';
                 }
-                else if (usage.typeVar.details.boundType) {
-                    altTypeText = `"${this._evaluator.printType((0, typeUtils_1.convertToInstance)(usage.typeVar.details.boundType))}"`;
+                else if (usage.typeVar.shared.boundType) {
+                    altTypeText = `"${this._evaluator.printType((0, typeUtils_1.convertToInstance)(usage.typeVar.shared.boundType))}"`;
                 }
                 else {
                     altTypeText = '"object"';
@@ -1711,21 +1718,21 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     type: altTypeText,
                 }));
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, localize_1.LocMessage.typeVarUsedOnlyOnce().format({
-                    name: usage.nodes[0].value,
+                    name: usage.nodes[0].d.value,
                 }) + diag.getString(), usage.nodes[0]);
             }
             // Report error for local type variable that appears in return type
             // (but not as a top-level TypeVar within a union) and appears only
             // within parameters that have default values. These may go unsolved.
             let isUsedInReturnType = usage.returnTypeUsageCount > 0;
-            if (usage.returnTypeUsageCount === 1 && type.details.declaredReturnType) {
+            if (usage.returnTypeUsageCount === 1 && type.shared.declaredReturnType) {
                 // If the TypeVar appears only once in the return type and it's a top-level
                 // TypeVar within a union, exempt it from this check. Although these
                 // TypeVars may go unsolved, they can be safely eliminated from the union
                 // without generating an Unknown type.
-                const returnType = type.details.declaredReturnType;
+                const returnType = type.shared.declaredReturnType;
                 if ((0, types_1.isUnion)(returnType) &&
-                    returnType.subtypes.some((subtype) => (0, types_1.isTypeVar)(subtype) && subtype.details.name === usage.nodes[0].value)) {
+                    returnType.priv.subtypes.some((subtype) => (0, types_1.isTypeVar)(subtype) && subtype.shared.name === usage.nodes[0].d.value)) {
                     isUsedInReturnType = false;
                 }
             }
@@ -1740,7 +1747,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 const diag = new diagnostic_1.DiagnosticAddendum();
                 diag.addMessage(localize_1.LocAddendum.typeVarUnsolvableRemedy());
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, localize_1.LocMessage.typeVarPossiblyUnsolvable().format({
-                    name: usage.nodes[0].value,
+                    name: usage.nodes[0].d.value,
                     param: (_a = usage.paramWithEllipsis) !== null && _a !== void 0 ? _a : '',
                 }) + diag.getString(), usage.nodes[0]);
             }
@@ -1755,7 +1762,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 const diag = new diagnostic_1.DiagnosticAddendum();
                 diag.addMessage(localize_1.LocAddendum.typeVarUnsolvableRemedy());
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, localize_1.LocMessage.typeVarPossiblyUnsolvable().format({
-                    name: usage.nodes[0].value,
+                    name: usage.nodes[0].d.value,
                     param: (_a = usage.paramWithEllipsis) !== null && _a !== void 0 ? _a : '',
                 }) + diag.getString(), usage.nodes[0]);
             }
@@ -1766,7 +1773,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         var _a, _b, _c, _d, _e, _f;
         let staticMethodCount = 0;
         let classMethodCount = 0;
-        functionType.overloads.forEach((overload) => {
+        functionType.priv.overloads.forEach((overload) => {
             if (types_1.FunctionType.isStaticMethod(overload)) {
                 staticMethodCount++;
             }
@@ -1774,15 +1781,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 classMethodCount++;
             }
         });
-        if (staticMethodCount > 0 && staticMethodCount < functionType.overloads.length) {
+        if (staticMethodCount > 0 && staticMethodCount < functionType.priv.overloads.length) {
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadStaticMethodInconsistent().format({
-                name: node.name.value,
-            }), (_c = (_b = (_a = functionType.overloads[0]) === null || _a === void 0 ? void 0 : _a.details.declaration) === null || _b === void 0 ? void 0 : _b.node.name) !== null && _c !== void 0 ? _c : node.name);
+                name: node.d.name.d.value,
+            }), (_c = (_b = (_a = functionType.priv.overloads[0]) === null || _a === void 0 ? void 0 : _a.shared.declaration) === null || _b === void 0 ? void 0 : _b.node.d.name) !== null && _c !== void 0 ? _c : node.d.name);
         }
-        if (classMethodCount > 0 && classMethodCount < functionType.overloads.length) {
+        if (classMethodCount > 0 && classMethodCount < functionType.priv.overloads.length) {
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadClassMethodInconsistent().format({
-                name: node.name.value,
-            }), (_f = (_e = (_d = functionType.overloads[0]) === null || _d === void 0 ? void 0 : _d.details.declaration) === null || _e === void 0 ? void 0 : _e.node.name) !== null && _f !== void 0 ? _f : node.name);
+                name: node.d.name.d.value,
+            }), (_f = (_e = (_d = functionType.priv.overloads[0]) === null || _d === void 0 ? void 0 : _d.shared.declaration) === null || _e === void 0 ? void 0 : _e.node.d.name) !== null && _f !== void 0 ? _f : node.d.name);
         }
     }
     // Validates that overloads do not overlap with inconsistent return results.
@@ -1791,10 +1798,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const prevOverload = prevOverloads[i];
             if (this._isOverlappingOverload(functionType, prevOverload, /* partialOverlap */ false)) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOverlappingOverload, localize_1.LocMessage.overlappingOverload().format({
-                    name: node.name.value,
+                    name: node.d.name.d.value,
                     obscured: prevOverloads.length + 1,
                     obscuredBy: i + 1,
-                }), node.name);
+                }), node.d.name);
                 break;
             }
         }
@@ -1810,10 +1817,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     /* srcTypeVarContext */ undefined, 8 /* AssignTypeFlags.SkipSolveTypeVars */ | 1024 /* AssignTypeFlags.IgnoreTypeVarScope */)) {
                     const altNode = this._findNodeForOverload(node, prevOverload);
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOverlappingOverload, localize_1.LocMessage.overloadReturnTypeMismatch().format({
-                        name: node.name.value,
+                        name: node.d.name.d.value,
                         newIndex: prevOverloads.length + 1,
                         prevIndex: i + 1,
-                    }), (altNode || node).name);
+                    }), (altNode || node).d.name);
                     break;
                 }
             }
@@ -1823,7 +1830,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // earlier overload. Typeshed stubs contain type: ignore comments on these
     // lines, so it is important for us to report them in the same manner.
     _findNodeForOverload(functionNode, overloadType) {
-        const decls = this._evaluator.getDeclarationsForNameNode(functionNode.name);
+        const decls = this._evaluator.getDeclarationsForNameNode(functionNode.d.name);
         if (!decls) {
             return undefined;
         }
@@ -1843,15 +1850,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // the case, but for consistency with other type checkers, we'll honor
         // this rule. See https://github.com/python/typing/issues/253#issuecomment-389262904
         // for details.
-        if (types_1.FunctionType.isInstanceMethod(functionType) && functionType.details.name === '__get__') {
+        if (types_1.FunctionType.isInstanceMethod(functionType) && functionType.shared.name === '__get__') {
             return false;
         }
-        let flags = 64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */ | 16 /* AssignTypeFlags.OverloadOverlapCheck */;
+        let flags = 64 /* AssignTypeFlags.SkipReturnTypeCheck */ | 16 /* AssignTypeFlags.OverloadOverlap */;
         if (partialOverlap) {
-            flags |= 32 /* AssignTypeFlags.PartialOverloadOverlapCheck */;
+            flags |= 32 /* AssignTypeFlags.PartialOverloadOverlap */;
         }
         return this._evaluator.assignType(functionType, prevOverload, 
-        /* diag */ undefined, new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(functionType)), 
+        /* diag */ undefined, new typeVarContext_1.TypeVarContext(), 
         /* srcTypeVarContext */ undefined, flags);
     }
     _isLegalOverloadImplementation(overload, implementation, diag) {
@@ -1859,12 +1866,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const implTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(implementation));
         const overloadTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overload));
         // First check the parameters to see if they are assignable.
-        let isLegal = this._evaluator.assignType(overload, implementation, diag, overloadTypeVarContext, implTypeVarContext, 64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */ |
+        let isLegal = this._evaluator.assignType(overload, implementation, diag, overloadTypeVarContext, implTypeVarContext, 64 /* AssignTypeFlags.SkipReturnTypeCheck */ |
             2 /* AssignTypeFlags.ReverseTypeVarMatching */ |
             512 /* AssignTypeFlags.SkipSelfClsTypeCheck */);
         // Now check the return types.
-        const overloadReturnType = (_a = overload.details.declaredReturnType) !== null && _a !== void 0 ? _a : this._evaluator.getFunctionInferredReturnType(overload);
-        const implementationReturnType = (0, typeUtils_1.applySolvedTypeVars)(implementation.details.declaredReturnType || this._evaluator.getFunctionInferredReturnType(implementation), implTypeVarContext);
+        const overloadReturnType = (_a = overload.shared.declaredReturnType) !== null && _a !== void 0 ? _a : this._evaluator.getFunctionInferredReturnType(overload);
+        const implementationReturnType = (0, typeUtils_1.applySolvedTypeVars)(implementation.shared.declaredReturnType || this._evaluator.getFunctionInferredReturnType(implementation), implTypeVarContext);
         const returnDiag = new diagnostic_1.DiagnosticAddendum();
         if (!(0, types_1.isNever)(overloadReturnType) &&
             !this._evaluator.assignType(implementationReturnType, overloadReturnType, returnDiag.createAddendum(), implTypeVarContext, overloadTypeVarContext, 8 /* AssignTypeFlags.SkipSolveTypeVars */)) {
@@ -1919,7 +1926,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 break;
             }
             case 47 /* ParseNodeType.StatementList */: {
-                for (const substatement of statement.statements) {
+                for (const substatement of statement.d.statements) {
                     let isValid = true;
                     switch (substatement.nodeType) {
                         case 2 /* ParseNodeType.Assert */:
@@ -1959,17 +1966,17 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         case 5 /* ParseNodeType.AugmentedAssignment */: {
                             // Exempt __all__ manipulations.
                             isValid =
-                                substatement.operator === 1 /* OperatorType.AddEqual */ &&
-                                    substatement.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
-                                    substatement.leftExpression.value === '__all__';
+                                substatement.d.operator === 1 /* OperatorType.AddEqual */ &&
+                                    substatement.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ &&
+                                    substatement.d.leftExpr.d.value === '__all__';
                             break;
                         }
                         case 9 /* ParseNodeType.Call */: {
                             // Exempt __all__ manipulations.
                             isValid =
-                                substatement.leftExpression.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
-                                    substatement.leftExpression.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
-                                    substatement.leftExpression.leftExpression.value === '__all__';
+                                substatement.d.leftExpr.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
+                                    substatement.d.leftExpr.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ &&
+                                    substatement.d.leftExpr.d.leftExpr.d.value === '__all__';
                             break;
                         }
                     }
@@ -2009,8 +2016,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                     return;
                 }
-                if (allowTuple && exceptionSubtype.tupleTypeArguments) {
-                    exceptionSubtype.tupleTypeArguments.forEach((typeArg) => {
+                if (allowTuple && exceptionSubtype.priv.tupleTypeArguments) {
+                    exceptionSubtype.priv.tupleTypeArguments.forEach((typeArg) => {
                         this._validateExceptionTypeRecursive(typeArg.type, diag, baseExceptionType, baseExceptionGroupType, 
                         /* allowTuple */ false, isExceptGroup);
                     });
@@ -2044,8 +2051,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         nodes.forEach((node) => {
-            if (!moduleScope.symbolTable.has(node.value)) {
-                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnsupportedDunderAll, localize_1.LocMessage.dunderAllSymbolNotPresent().format({ name: node.value }), node);
+            if (!moduleScope.symbolTable.has(node.d.value)) {
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnsupportedDunderAll, localize_1.LocMessage.dunderAllSymbolNotPresent().format({ name: node.d.value }), node);
             }
         });
     }
@@ -2068,8 +2075,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const accessedSymbolSet = this._fileInfo.accessedSymbolSet;
         for (const paramList of this._typeParameterLists) {
             const typeParamScope = AnalyzerNodeInfo.getScope(paramList);
-            for (const param of paramList.parameters) {
-                const symbol = typeParamScope === null || typeParamScope === void 0 ? void 0 : typeParamScope.symbolTable.get(param.name.value);
+            for (const param of paramList.d.params) {
+                const symbol = typeParamScope === null || typeParamScope === void 0 ? void 0 : typeParamScope.symbolTable.get(param.d.name.d.value);
                 if (!symbol) {
                     // This can happen if the code is unreachable.
                     return;
@@ -2103,18 +2110,18 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // overloaded signature. We'll exempt it from this check.
         if ((0, types_1.isOverloadedFunction)(type)) {
             const overloads = types_1.OverloadedFunctionType.getOverloads(type);
-            if (overloads.length > 0 && overloads[0].details.name === '') {
+            if (overloads.length > 0 && overloads[0].shared.name === '') {
                 return;
             }
         }
         else if ((0, types_1.isFunction)(type)) {
-            if (type.details.name === '') {
+            if (type.shared.name === '') {
                 return;
             }
         }
         if (overloadedFunctions.length === 1) {
             // There should never be a single overload.
-            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.singleOverload().format({ name }), primaryDecl.node.name);
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.singleOverload().format({ name }), primaryDecl.node.d.name);
         }
         // If the file is not a stub and this is the first overload,
         // verify that there is an implementation.
@@ -2147,8 +2154,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // If this is a method within a protocol class, don't require that
             // there is an implementation.
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportNoOverloadImplementation, localize_1.LocMessage.overloadWithoutImplementation().format({
-                name: primaryDecl.node.name.value,
-            }), primaryDecl.node.name);
+                name: primaryDecl.node.d.name.d.value,
+            }), primaryDecl.node.d.name);
             return;
         }
         if (!(0, types_1.isOverloadedFunction)(type)) {
@@ -2159,13 +2166,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             var _a, _b, _c, _d;
             const diag = new diagnostic_1.DiagnosticAddendum();
             if (!this._isLegalOverloadImplementation(overload, implementationFunction, diag)) {
-                if (implementationFunction.details.declaration) {
+                if (implementationFunction.shared.declaration) {
                     const diagnostic = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadImplementationMismatch().format({
                         name,
                         index: index + 1,
-                    }) + diag.getString(), implementationFunction.details.declaration.node.name);
-                    if (diagnostic && overload.details.declaration) {
-                        diagnostic.addRelatedInfo(localize_1.LocAddendum.overloadSignature(), (_b = (_a = overload.details.declaration) === null || _a === void 0 ? void 0 : _a.uri) !== null && _b !== void 0 ? _b : primaryDecl.uri, (_d = (_c = overload.details.declaration) === null || _c === void 0 ? void 0 : _c.range) !== null && _d !== void 0 ? _d : primaryDecl.range);
+                    }) + diag.getString(), implementationFunction.shared.declaration.node.d.name);
+                    if (diagnostic && overload.shared.declaration) {
+                        diagnostic.addRelatedInfo(localize_1.LocAddendum.overloadSignature(), (_b = (_a = overload.shared.declaration) === null || _a === void 0 ? void 0 : _a.uri) !== null && _b !== void 0 ? _b : primaryDecl.uri, (_d = (_c = overload.shared.declaration) === null || _c === void 0 ? void 0 : _c.range) !== null && _d !== void 0 ? _d : primaryDecl.range);
                     }
                 }
             }
@@ -2297,7 +2304,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     types_1.ClassType.isPropertyClass(decoratedType) &&
                     (0, types_1.isClassInstance)(funcTypeInfo.decoratedType) &&
                     types_1.ClassType.isPropertyClass(funcTypeInfo.decoratedType)) {
-                    return funcTypeInfo.decoratedType.details.typeSourceId !== decoratedType.details.typeSourceId;
+                    return funcTypeInfo.decoratedType.shared.typeSourceId !== decoratedType.shared.typeSourceId;
                 }
                 return !types_1.FunctionType.isOverloaded(funcTypeInfo.functionType);
             });
@@ -2334,7 +2341,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (diag) {
                 let primaryDeclNode;
                 if (primaryDecl.type === 5 /* DeclarationType.Function */ || primaryDecl.type === 6 /* DeclarationType.Class */) {
-                    primaryDeclNode = primaryDecl.node.name;
+                    primaryDeclNode = primaryDecl.node.d.name;
                 }
                 else if (primaryDecl.type === 1 /* DeclarationType.Variable */) {
                     if (primaryDecl.node.nodeType === 38 /* ParseNodeType.Name */) {
@@ -2343,8 +2350,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 else if (primaryDecl.type === 2 /* DeclarationType.Parameter */ ||
                     primaryDecl.type === 3 /* DeclarationType.TypeParameter */) {
-                    if (primaryDecl.node.name) {
-                        primaryDeclNode = primaryDecl.node.name;
+                    if (primaryDecl.node.d.name) {
+                        primaryDeclNode = primaryDecl.node.d.name;
                     }
                 }
                 if (primaryDeclNode) {
@@ -2361,7 +2368,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     duplicateIsOk = true;
                 }
                 if (!duplicateIsOk) {
-                    const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportRedeclaration, localize_1.LocMessage.obscuredClassDeclaration().format({ name }), otherDecl.node.name);
+                    const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportRedeclaration, localize_1.LocMessage.obscuredClassDeclaration().format({ name }), otherDecl.node.d.name);
                     addPrimaryDeclInfo(diag);
                 }
             }
@@ -2396,12 +2403,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (!duplicateIsOk) {
                     const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportRedeclaration, otherDecl.isMethod
                         ? localize_1.LocMessage.obscuredMethodDeclaration().format({ name })
-                        : localize_1.LocMessage.obscuredFunctionDeclaration().format({ name }), otherDecl.node.name);
+                        : localize_1.LocMessage.obscuredFunctionDeclaration().format({ name }), otherDecl.node.d.name);
                     addPrimaryDeclInfo(diag);
                 }
             }
             else if (otherDecl.type === 2 /* DeclarationType.Parameter */) {
-                if (otherDecl.node.name) {
+                if (otherDecl.node.d.name) {
                     let duplicateIsOk = false;
                     if (primaryDecl.type === 3 /* DeclarationType.TypeParameter */) {
                         // The error will be reported elsewhere if a type parameter is
@@ -2410,7 +2417,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                     if (!duplicateIsOk) {
                         const message = localize_1.LocMessage.obscuredParameterDeclaration();
-                        const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportRedeclaration, message.format({ name }), otherDecl.node.name);
+                        const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportRedeclaration, message.format({ name }), otherDecl.node.d.name);
                         addPrimaryDeclInfo(diag);
                     }
                 }
@@ -2438,7 +2445,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             }
             else if (otherDecl.type === 4 /* DeclarationType.TypeAlias */) {
-                const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportRedeclaration, localize_1.LocMessage.obscuredTypeAliasDeclaration().format({ name }), otherDecl.node.name);
+                const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportRedeclaration, localize_1.LocMessage.obscuredTypeAliasDeclaration().format({ name }), otherDecl.node.d.name);
                 addPrimaryDeclInfo(diag);
             }
         }
@@ -2477,19 +2484,19 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 diagnosticLevel = this._fileInfo.diagnosticRuleSet.reportUnusedImport;
                 rule = diagnosticRules_1.DiagnosticRule.reportUnusedImport;
                 if (decl.node.nodeType === 24 /* ParseNodeType.ImportAs */) {
-                    if (decl.node.alias) {
+                    if (decl.node.d.alias) {
                         // For statements of the form "import x as x", don't mark "x" as unaccessed
                         // because it's assumed to be re-exported.
                         // See https://typing.readthedocs.io/en/latest/source/stubs.html#imports.
-                        if (decl.node.alias.value !== decl.moduleName) {
-                            nameNode = decl.node.alias;
+                        if (decl.node.d.alias.d.value !== decl.moduleName) {
+                            nameNode = decl.node.d.alias;
                         }
                     }
                     else {
                         // Handle multi-part names specially.
-                        const nameParts = decl.node.module.nameParts;
+                        const nameParts = decl.node.d.module.d.nameParts;
                         if (nameParts.length > 0) {
-                            const multipartName = nameParts.map((np) => np.value).join('.');
+                            const multipartName = nameParts.map((np) => np.d.value).join('.');
                             let textRange = { start: nameParts[0].start, length: nameParts[0].length };
                             textRange = textRange_1.TextRange.extend(textRange, nameParts[nameParts.length - 1]);
                             this._fileInfo.diagnosticSink.addUnusedCodeWithTextRange(localize_1.LocMessage.unaccessedSymbol().format({ name: multipartName }), textRange, { action: "pyright.unusedImport" /* Commands.unusedImport */ });
@@ -2502,16 +2509,16 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     const importFrom = decl.node.parent;
                     // For statements of the form "from y import x as x", don't mark "x" as
                     // unaccessed because it's assumed to be re-exported.
-                    const isReexport = ((_a = decl.node.alias) === null || _a === void 0 ? void 0 : _a.value) === decl.node.name.value;
+                    const isReexport = ((_a = decl.node.d.alias) === null || _a === void 0 ? void 0 : _a.d.value) === decl.node.d.name.d.value;
                     // If this is a __future__ import, it's OK for the import symbol to be unaccessed.
-                    const isFuture = importFrom.module.nameParts.length === 1 &&
-                        importFrom.module.nameParts[0].value === '__future__';
+                    const isFuture = importFrom.d.module.d.nameParts.length === 1 &&
+                        importFrom.d.module.d.nameParts[0].d.value === '__future__';
                     if (!isReexport && !isFuture) {
-                        nameNode = decl.node.alias || decl.node.name;
+                        nameNode = decl.node.d.alias || decl.node.d.name;
                     }
                 }
                 if (nameNode) {
-                    message = localize_1.LocMessage.unaccessedImport().format({ name: nameNode.value });
+                    message = localize_1.LocMessage.unaccessedImport().format({ name: nameNode.d.value });
                 }
                 break;
             case 4 /* DeclarationType.TypeAlias */:
@@ -2530,18 +2537,18 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     nameNode = decl.node;
                     // Don't emit a diagnostic if the name starts with an underscore.
                     // This indicates that the variable is unused.
-                    if (nameNode.value.startsWith('_')) {
+                    if (nameNode.d.value.startsWith('_')) {
                         diagnosticLevel = 'none';
                     }
                 }
                 else if (decl.node.nodeType === 41 /* ParseNodeType.Parameter */) {
-                    nameNode = decl.node.name;
+                    nameNode = decl.node.d.name;
                     // Don't emit a diagnostic for unused parameters or type parameters.
                     diagnosticLevel = 'none';
                 }
                 if (nameNode) {
                     rule = diagnosticRules_1.DiagnosticRule.reportUnusedVariable;
-                    message = localize_1.LocMessage.unaccessedVariable().format({ name: nameNode.value });
+                    message = localize_1.LocMessage.unaccessedVariable().format({ name: nameNode.d.value });
                 }
                 break;
             case 6 /* DeclarationType.Class */:
@@ -2554,9 +2561,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     return;
                 }
                 diagnosticLevel = this._fileInfo.diagnosticRuleSet.reportUnusedClass;
-                nameNode = decl.node.name;
+                nameNode = decl.node.d.name;
                 rule = diagnosticRules_1.DiagnosticRule.reportUnusedClass;
-                message = localize_1.LocMessage.unaccessedClass().format({ name: nameNode.value });
+                message = localize_1.LocMessage.unaccessedClass().format({ name: nameNode.d.value });
                 break;
             case 5 /* DeclarationType.Function */:
                 if (!isPrivate) {
@@ -2568,14 +2575,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     return;
                 }
                 diagnosticLevel = this._fileInfo.diagnosticRuleSet.reportUnusedFunction;
-                nameNode = decl.node.name;
+                nameNode = decl.node.d.name;
                 rule = diagnosticRules_1.DiagnosticRule.reportUnusedFunction;
-                message = localize_1.LocMessage.unaccessedFunction().format({ name: nameNode.value });
+                message = localize_1.LocMessage.unaccessedFunction().format({ name: nameNode.d.value });
                 break;
             case 3 /* DeclarationType.TypeParameter */:
                 // Never report a diagnostic for an unused TypeParameter.
                 diagnosticLevel = 'none';
-                nameNode = decl.node.name;
+                nameNode = decl.node.d.name;
                 break;
             case 0 /* DeclarationType.Intrinsic */:
             case 7 /* DeclarationType.SpecialBuiltInClass */:
@@ -2585,7 +2592,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         const action = rule === diagnosticRules_1.DiagnosticRule.reportUnusedImport ? { action: "pyright.unusedImport" /* Commands.unusedImport */ } : undefined;
         if (nameNode) {
-            this._fileInfo.diagnosticSink.addUnusedCodeWithTextRange(localize_1.LocMessage.unaccessedSymbol().format({ name: nameNode.value }), nameNode, action);
+            this._fileInfo.diagnosticSink.addUnusedCodeWithTextRange(localize_1.LocMessage.unaccessedSymbol().format({ name: nameNode.d.value }), nameNode, action);
             if (rule !== undefined && message && diagnosticLevel !== 'none') {
                 this._evaluator.addDiagnostic(rule, message, nameNode);
             }
@@ -2595,14 +2602,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // common source of programming errors. Also validates that arguments passed
     // to isinstance or issubclass won't generate exceptions.
     _validateIsInstanceCall(node) {
-        if (node.leftExpression.nodeType !== 38 /* ParseNodeType.Name */ ||
-            (node.leftExpression.value !== 'isinstance' && node.leftExpression.value !== 'issubclass') ||
-            node.arguments.length !== 2) {
+        if (node.d.leftExpr.nodeType !== 38 /* ParseNodeType.Name */ ||
+            (node.d.leftExpr.d.value !== 'isinstance' && node.d.leftExpr.d.value !== 'issubclass') ||
+            node.d.args.length !== 2) {
             return;
         }
-        const callName = node.leftExpression.value;
+        const callName = node.d.leftExpr.d.value;
         const isInstanceCheck = callName === 'isinstance';
-        let arg0Type = this._evaluator.getType(node.arguments[0].valueExpression);
+        let arg0Type = this._evaluator.getType(node.d.args[0].d.valueExpr);
         if (!arg0Type) {
             return;
         }
@@ -2610,15 +2617,17 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(subtype);
         });
         arg0Type = this._evaluator.expandPromotionTypes(node, arg0Type);
-        const arg1Type = this._evaluator.getType(node.arguments[1].valueExpression);
+        const arg1Type = this._evaluator.getType(node.d.args[1].d.valueExpr);
         if (!arg1Type) {
             return;
         }
         let isValidType = true;
         const diag = new diagnostic_1.DiagnosticAddendum();
         (0, typeUtils_1.doForEachSubtype)(arg1Type, (arg1Subtype) => {
-            if ((0, types_1.isClassInstance)(arg1Subtype) && types_1.ClassType.isTupleClass(arg1Subtype) && arg1Subtype.tupleTypeArguments) {
-                if (arg1Subtype.tupleTypeArguments.some((typeArg) => !this._isTypeSupportedTypeForIsInstance(typeArg.type, isInstanceCheck, diag))) {
+            if ((0, types_1.isClassInstance)(arg1Subtype) &&
+                types_1.ClassType.isTupleClass(arg1Subtype) &&
+                arg1Subtype.priv.tupleTypeArguments) {
+                if (arg1Subtype.priv.tupleTypeArguments.some((typeArg) => !this._isTypeSupportedTypeForIsInstance(typeArg.type, isInstanceCheck, diag))) {
                     isValidType = false;
                 }
             }
@@ -2635,7 +2644,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }) + diag.getString()
                 : localize_1.LocMessage.isSubclassInvalidType().format({
                     type: this._evaluator.printType(arg1Type),
-                }) + diag.getString(), node.arguments[1]);
+                }) + diag.getString(), node.d.args[1]);
         }
         // If this call is an issubclass, check for the use of a "data protocol",
         // which PEP 544 says cannot be used in issubclass.
@@ -2644,8 +2653,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             (0, typeUtils_1.doForEachSubtype)(arg1Type, (arg1Subtype) => {
                 if ((0, types_1.isClassInstance)(arg1Subtype) &&
                     types_1.ClassType.isTupleClass(arg1Subtype) &&
-                    arg1Subtype.tupleTypeArguments) {
-                    arg1Subtype.tupleTypeArguments.forEach((typeArg) => {
+                    arg1Subtype.priv.tupleTypeArguments) {
+                    arg1Subtype.priv.tupleTypeArguments.forEach((typeArg) => {
                         this._validateNotDataProtocol(typeArg.type, diag);
                     });
                 }
@@ -2654,7 +2663,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             });
             if (!diag.isEmpty()) {
-                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataProtocolInSubclassCheck(), node.arguments[1]);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataProtocolInSubclassCheck(), node.d.args[1]);
             }
         }
         // If this call is within an assert statement, we won't check whether
@@ -2682,33 +2691,33 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         (0, typeUtils_1.doForEachSubtype)(arg1Type, (arg1Subtype) => {
             if ((0, types_1.isClass)(arg1Subtype)) {
                 if (types_1.TypeBase.isInstantiable(arg1Subtype)) {
-                    if (arg1Subtype.literalValue === undefined) {
+                    if (arg1Subtype.priv.literalValue === undefined) {
                         classTypeList.push(arg1Subtype);
                         if (types_1.ClassType.isBuiltIn(arg1Subtype) &&
-                            nonstandardClassTypes.some((name) => name === arg1Subtype.details.name)) {
+                            nonstandardClassTypes.some((name) => name === arg1Subtype.shared.name)) {
                             isValidType = false;
                         }
-                        if (arg1Subtype.includeSubclasses) {
+                        if (arg1Subtype.priv.includeSubclasses) {
                             arg1IncludesSubclasses = true;
                         }
                     }
                     if (arg0Type) {
-                        this._validateUnsafeProtocolOverlap(node.arguments[0].valueExpression, (0, typeUtils_1.convertToInstance)(arg1Subtype), isInstanceCheck ? arg0Type : (0, typeUtils_1.convertToInstance)(arg0Type));
+                        this._validateUnsafeProtocolOverlap(node.d.args[0].d.valueExpr, (0, typeUtils_1.convertToInstance)(arg1Subtype), isInstanceCheck ? arg0Type : (0, typeUtils_1.convertToInstance)(arg0Type));
                     }
                 }
                 else {
                     // The isinstance and issubclass call supports a variation where the second
                     // parameter is a tuple of classes.
                     if ((0, typeUtils_1.isTupleClass)(arg1Subtype)) {
-                        if (arg1Subtype.tupleTypeArguments) {
-                            arg1Subtype.tupleTypeArguments.forEach((typeArg) => {
+                        if (arg1Subtype.priv.tupleTypeArguments) {
+                            arg1Subtype.priv.tupleTypeArguments.forEach((typeArg) => {
                                 if ((0, types_1.isInstantiableClass)(typeArg.type)) {
                                     classTypeList.push(typeArg.type);
-                                    if (typeArg.type.includeSubclasses) {
+                                    if (typeArg.type.priv.includeSubclasses) {
                                         arg1IncludesSubclasses = true;
                                     }
                                     if (arg0Type) {
-                                        this._validateUnsafeProtocolOverlap(node.arguments[0].valueExpression, (0, typeUtils_1.convertToInstance)(typeArg.type), isInstanceCheck ? arg0Type : (0, typeUtils_1.convertToInstance)(arg0Type));
+                                        this._validateUnsafeProtocolOverlap(node.d.args[0].d.valueExpr, (0, typeUtils_1.convertToInstance)(typeArg.type), isInstanceCheck ? arg0Type : (0, typeUtils_1.convertToInstance)(arg0Type));
                                     }
                                 }
                                 else {
@@ -2718,12 +2727,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                     }
                     else {
-                        if (arg1Subtype.includeSubclasses) {
+                        if (arg1Subtype.priv.includeSubclasses) {
                             arg1IncludesSubclasses = true;
                         }
                     }
                     if (types_1.ClassType.isBuiltIn(arg1Subtype) &&
-                        nonstandardClassTypes.some((name) => name === arg1Subtype.details.name)) {
+                        nonstandardClassTypes.some((name) => name === arg1Subtype.shared.name)) {
                         isValidType = false;
                     }
                 }
@@ -2834,14 +2843,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     if ((0, protocols_1.isProtocolUnsafeOverlap)(this._evaluator, protocol, testSubtype)) {
                         isUnsafeOverlap = true;
                         diag.addMessage(localize_1.LocAddendum.protocolUnsafeOverlap().format({
-                            name: testSubtype.details.name,
+                            name: testSubtype.shared.name,
                         }));
                     }
                 }
             });
             if (isUnsafeOverlap) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.protocolUnsafeOverlap().format({
-                    name: protocol.details.name,
+                    name: protocol.shared.name,
                 }) + diag.getString(), errorNode);
             }
         }
@@ -2851,9 +2860,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     _isTypeSupportedTypeForIsInstance(type, isInstanceCheck, diag) {
         let isSupported = true;
         (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+            var _a, _b;
             subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
             subtype = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(subtype);
-            if (subtype.specialForm && types_1.ClassType.isBuiltIn(subtype.specialForm, 'TypeAliasType')) {
+            if (((_a = subtype.props) === null || _a === void 0 ? void 0 : _a.specialForm) && types_1.ClassType.isBuiltIn(subtype.props.specialForm, 'TypeAliasType')) {
                 diag.addMessage(localize_1.LocAddendum.typeAliasInstanceCheck());
                 isSupported = false;
                 return;
@@ -2880,19 +2890,19 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         diag.addMessage(localize_1.LocAddendum.typedDictClassNotAllowed());
                         isSupported = false;
                     }
-                    else if (subtype.isTypeArgumentExplicit && !subtype.includeSubclasses) {
+                    else if (subtype.priv.isTypeArgumentExplicit && !subtype.priv.includeSubclasses) {
                         // If it's a class, make sure that it has not been given explicit
                         // type arguments. This will result in a TypeError exception.
                         diag.addMessage(localize_1.LocAddendum.genericClassNotAllowed());
                         isSupported = false;
                     }
                     else if (types_1.ClassType.isIllegalIsinstanceClass(subtype)) {
-                        diag.addMessage(localize_1.LocAddendum.isinstanceClassNotSupported().format({ type: subtype.details.name }));
+                        diag.addMessage(localize_1.LocAddendum.isinstanceClassNotSupported().format({ type: subtype.shared.name }));
                         isSupported = false;
                     }
                     else if (types_1.ClassType.isProtocolClass(subtype) &&
                         !types_1.ClassType.isRuntimeCheckable(subtype) &&
-                        !subtype.includeSubclasses) {
+                        !subtype.priv.includeSubclasses) {
                         // According to PEP 544, protocol classes cannot be used as the right-hand
                         // argument to isinstance or issubclass unless they are annotated as
                         // "runtime checkable".
@@ -2903,15 +2913,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         diag.addMessage(localize_1.LocAddendum.newTypeClassNotAllowed());
                         isSupported = false;
                     }
-                    else if (subtype.specialForm &&
-                        (0, types_1.isInstantiableClass)(subtype.specialForm) &&
-                        types_1.ClassType.isBuiltIn(subtype.specialForm, 'Annotated')) {
+                    else if (((_b = subtype.props) === null || _b === void 0 ? void 0 : _b.specialForm) &&
+                        (0, types_1.isInstantiableClass)(subtype.props.specialForm) &&
+                        types_1.ClassType.isBuiltIn(subtype.props.specialForm, 'Annotated')) {
                         diag.addMessage(localize_1.LocAddendum.annotatedNotAllowed());
                         isSupported = false;
                     }
                     break;
                 case 4 /* TypeCategory.Function */:
-                    if (!types_1.TypeBase.isInstantiable(subtype) || subtype.isCallableWithTypeArgs) {
+                    if (!types_1.TypeBase.isInstantiable(subtype) || subtype.priv.isCallableWithTypeArgs) {
                         diag.addMessage(localize_1.LocAddendum.genericClassNotAllowed());
                         isSupported = false;
                     }
@@ -2927,7 +2937,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     _validateNotDataProtocol(type, diag) {
         if ((0, types_1.isInstantiableClass)(type) && types_1.ClassType.isProtocolClass(type) && !(0, protocols_1.isMethodOnlyProtocol)(type)) {
             diag.addMessage(localize_1.LocAddendum.dataProtocolUnsupported().format({
-                name: type.details.name,
+                name: type.shared.name,
             }));
         }
     }
@@ -2953,30 +2963,30 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             !types_1.ClassType.isClassProperty(functionTypeResult.decoratedType)) {
             return;
         }
-        this._reportDeprecatedDiagnostic(node.name, localize_1.LocMessage.classPropertyDeprecated());
+        this._reportDeprecatedDiagnostic(node.d.name, localize_1.LocMessage.classPropertyDeprecated());
     }
     _reportDeprecatedUseForMemberAccess(node, info) {
         let errorMessage;
         if (info.accessType === 'property') {
             if (info.accessMethod === 'get') {
-                errorMessage = localize_1.LocMessage.deprecatedPropertyGetter().format({ name: node.value });
+                errorMessage = localize_1.LocMessage.deprecatedPropertyGetter().format({ name: node.d.value });
             }
             else if (info.accessMethod === 'set') {
-                errorMessage = localize_1.LocMessage.deprecatedPropertySetter().format({ name: node.value });
+                errorMessage = localize_1.LocMessage.deprecatedPropertySetter().format({ name: node.d.value });
             }
             else {
-                errorMessage = localize_1.LocMessage.deprecatedPropertyDeleter().format({ name: node.value });
+                errorMessage = localize_1.LocMessage.deprecatedPropertyDeleter().format({ name: node.d.value });
             }
         }
         else if (info.accessType === 'descriptor') {
             if (info.accessMethod === 'get') {
-                errorMessage = localize_1.LocMessage.deprecatedDescriptorGetter().format({ name: node.value });
+                errorMessage = localize_1.LocMessage.deprecatedDescriptorGetter().format({ name: node.d.value });
             }
             else if (info.accessMethod === 'set') {
-                errorMessage = localize_1.LocMessage.deprecatedDescriptorSetter().format({ name: node.value });
+                errorMessage = localize_1.LocMessage.deprecatedDescriptorSetter().format({ name: node.d.value });
             }
             else {
-                errorMessage = localize_1.LocMessage.deprecatedDescriptorDeleter().format({ name: node.value });
+                errorMessage = localize_1.LocMessage.deprecatedDescriptorDeleter().format({ name: node.d.value });
             }
         }
         if (errorMessage) {
@@ -2984,26 +2994,26 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
     }
     _reportDeprecatedUseForType(node, type, isImportFromTyping = false) {
-        var _a, _b;
+        var _a, _b, _c;
         if (!type) {
             return;
         }
         let errorMessage;
         let deprecatedMessage;
         function getDeprecatedMessageForFunction(functionType) {
-            if (functionType.details.declaration &&
-                functionType.details.declaration.node.nodeType === 31 /* ParseNodeType.Function */) {
-                const containingClass = ParseTreeUtils.getEnclosingClass(functionType.details.declaration.node, 
+            if (functionType.shared.declaration &&
+                functionType.shared.declaration.node.nodeType === 31 /* ParseNodeType.Function */) {
+                const containingClass = ParseTreeUtils.getEnclosingClass(functionType.shared.declaration.node, 
                 /* stopAtFunction */ true);
                 if (containingClass) {
                     return localize_1.LocMessage.deprecatedMethod().format({
-                        name: functionType.details.name || '<anonymous>',
-                        className: containingClass.name.value,
+                        name: functionType.shared.name || '<anonymous>',
+                        className: containingClass.d.name.d.value,
                     });
                 }
             }
             return localize_1.LocMessage.deprecatedFunction().format({
-                name: functionType.details.name,
+                name: functionType.shared.name,
             });
         }
         function getDeprecatedMessageForOverloadedCall(evaluator, type) {
@@ -3026,21 +3036,21 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 callTypeResult.overloadsUsedForCall &&
                 callTypeResult.overloadsUsedForCall.length > 0) {
                 callTypeResult.overloadsUsedForCall.forEach((overload) => {
-                    if (overload.details.deprecatedMessage !== undefined) {
-                        if (node.value === overload.details.name) {
-                            deprecatedMessage = overload.details.deprecatedMessage;
+                    if (overload.shared.deprecatedMessage !== undefined) {
+                        if (node.d.value === overload.shared.name) {
+                            deprecatedMessage = overload.shared.deprecatedMessage;
                             errorMessage = getDeprecatedMessageForFunction(overload);
                         }
-                        else if ((0, types_1.isInstantiableClass)(type) && overload.details.name === '__init__') {
-                            deprecatedMessage = overload.details.deprecatedMessage;
+                        else if ((0, types_1.isInstantiableClass)(type) && overload.shared.name === '__init__') {
+                            deprecatedMessage = overload.shared.deprecatedMessage;
                             errorMessage = localize_1.LocMessage.deprecatedConstructor().format({
-                                name: type.details.name,
+                                name: type.shared.name,
                             });
                         }
-                        else if ((0, types_1.isClassInstance)(type) && overload.details.name === '__call__') {
-                            deprecatedMessage = overload.details.deprecatedMessage;
+                        else if ((0, types_1.isClassInstance)(type) && overload.shared.name === '__call__') {
+                            deprecatedMessage = overload.shared.deprecatedMessage;
                             errorMessage = localize_1.LocMessage.deprecatedFunction().format({
-                                name: node.value,
+                                name: node.d.value,
                             });
                         }
                     }
@@ -3049,22 +3059,22 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
             if ((0, types_1.isClass)(subtype)) {
-                if (!subtype.includeSubclasses &&
-                    subtype.details.deprecatedMessage !== undefined &&
-                    node.value === subtype.details.name) {
-                    deprecatedMessage = subtype.details.deprecatedMessage;
-                    errorMessage = localize_1.LocMessage.deprecatedClass().format({ name: subtype.details.name });
+                if (!subtype.priv.includeSubclasses &&
+                    subtype.shared.deprecatedMessage !== undefined &&
+                    node.d.value === subtype.shared.name) {
+                    deprecatedMessage = subtype.shared.deprecatedMessage;
+                    errorMessage = localize_1.LocMessage.deprecatedClass().format({ name: subtype.shared.name });
                     return;
                 }
                 getDeprecatedMessageForOverloadedCall(this._evaluator, subtype);
                 return;
             }
             if ((0, types_1.isFunction)(subtype)) {
-                if (subtype.details.deprecatedMessage !== undefined) {
-                    if (!subtype.details.name ||
-                        subtype.details.name === '__call__' ||
-                        node.value === subtype.details.name) {
-                        deprecatedMessage = subtype.details.deprecatedMessage;
+                if (subtype.shared.deprecatedMessage !== undefined) {
+                    if (!subtype.shared.name ||
+                        subtype.shared.name === '__call__' ||
+                        node.d.value === subtype.shared.name) {
+                        deprecatedMessage = subtype.shared.deprecatedMessage;
                         errorMessage = getDeprecatedMessageForFunction(subtype);
                     }
                 }
@@ -3078,9 +3088,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 // If there the implementation itself is deprecated, assume it
                 // is deprecated even if it's outside of a call expression.
                 const overloadImpl = types_1.OverloadedFunctionType.getImplementation(subtype);
-                if ((overloadImpl === null || overloadImpl === void 0 ? void 0 : overloadImpl.details.deprecatedMessage) !== undefined) {
-                    if (!overloadImpl.details.name || node.value === overloadImpl.details.name) {
-                        deprecatedMessage = overloadImpl.details.deprecatedMessage;
+                if ((overloadImpl === null || overloadImpl === void 0 ? void 0 : overloadImpl.shared.deprecatedMessage) !== undefined) {
+                    if (!overloadImpl.shared.name || node.d.value === overloadImpl.shared.name) {
+                        deprecatedMessage = overloadImpl.shared.deprecatedMessage;
                         errorMessage = getDeprecatedMessageForFunction(overloadImpl);
                     }
                 }
@@ -3090,10 +3100,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._reportDeprecatedDiagnostic(node, errorMessage, deprecatedMessage);
         }
         if (this._fileInfo.diagnosticRuleSet.deprecateTypingAliases) {
-            const deprecatedForm = (_a = deprecatedSymbols_1.deprecatedAliases.get(node.value)) !== null && _a !== void 0 ? _a : deprecatedSymbols_1.deprecatedSpecialForms.get(node.value);
+            const deprecatedForm = (_a = deprecatedSymbols_1.deprecatedAliases.get(node.d.value)) !== null && _a !== void 0 ? _a : deprecatedSymbols_1.deprecatedSpecialForms.get(node.d.value);
             if (deprecatedForm) {
-                if (((0, types_1.isInstantiableClass)(type) && type.details.fullName === deprecatedForm.fullName) ||
-                    ((_b = type.typeAliasInfo) === null || _b === void 0 ? void 0 : _b.fullName) === deprecatedForm.fullName) {
+                if (((0, types_1.isInstantiableClass)(type) && type.shared.fullName === deprecatedForm.fullName) ||
+                    ((_c = (_b = type.props) === null || _b === void 0 ? void 0 : _b.typeAliasInfo) === null || _c === void 0 ? void 0 : _c.fullName) === deprecatedForm.fullName) {
                     if (this._fileInfo.executionEnvironment.pythonVersion.isGreaterOrEqualTo(deprecatedForm.version)) {
                         if (!deprecatedForm.typingImportOnly || isImportFromTyping) {
                             if (this._fileInfo.diagnosticRuleSet.reportDeprecated === 'none') {
@@ -3135,11 +3145,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (type) {
                 if ((0, types_1.isUnbound)(type)) {
                     if (this._evaluator.isNodeReachable(node)) {
-                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnboundVariable, localize_1.LocMessage.symbolIsUnbound().format({ name: node.value }), node);
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnboundVariable, localize_1.LocMessage.symbolIsUnbound().format({ name: node.d.value }), node);
                     }
                 }
                 else if ((0, types_1.isPossiblyUnbound)(type)) {
-                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportPossiblyUnboundVariable, localize_1.LocMessage.symbolIsPossiblyUnbound().format({ name: node.value }), node);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportPossiblyUnboundVariable, localize_1.LocMessage.symbolIsPossiblyUnbound().format({ name: node.d.value }), node);
                 }
             }
         }
@@ -3183,19 +3193,19 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // Skip this check for relative imports.
         const nodeModule = node.nodeType === 26 /* ParseNodeType.ImportFromAs */
             ? ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 25 /* ParseNodeType.ImportFrom */
-                ? (_b = node.parent) === null || _b === void 0 ? void 0 : _b.module
+                ? (_b = node.parent) === null || _b === void 0 ? void 0 : _b.d.module
                 : undefined
-            : node.module;
-        if (nodeModule === null || nodeModule === void 0 ? void 0 : nodeModule.leadingDots) {
+            : node.d.module;
+        if (nodeModule === null || nodeModule === void 0 ? void 0 : nodeModule.d.leadingDots) {
             return;
         }
         // Otherwise use the name to determine if a match for a stdlib module.
         const namePartNodes = node.nodeType === 24 /* ParseNodeType.ImportAs */
-            ? node.module.nameParts
+            ? node.d.module.d.nameParts
             : node.nodeType === 26 /* ParseNodeType.ImportFromAs */
-                ? [node.name]
-                : node.module.nameParts;
-        const nameParts = namePartNodes.map((n) => n.value);
+                ? [node.d.name]
+                : node.d.module.d.nameParts;
+        const nameParts = namePartNodes.map((n) => n.d.value);
         const module = {
             nameParts,
             leadingDots: 0,
@@ -3238,10 +3248,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         // Ignore privates in named arguments.
-        if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 1 /* ParseNodeType.Argument */ && node.parent.name === node) {
+        if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 1 /* ParseNodeType.Argument */ && node.parent.d.name === node) {
             return;
         }
-        const nameValue = node.value;
+        const nameValue = node.d.value;
         const isPrivateName = SymbolNameUtils.isPrivateName(nameValue);
         const isProtectedName = SymbolNameUtils.isProtectedName(nameValue);
         // If it's not a protected or private name, don't bother with
@@ -3329,9 +3339,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // Validates that an enum class does not attempt to override another
     // enum class that has already defined values.
     _validateEnumClassOverride(node, classType) {
-        classType.details.baseClasses.forEach((baseClass, index) => {
+        classType.shared.baseClasses.forEach((baseClass, index) => {
             if ((0, types_1.isClass)(baseClass) && (0, enums_1.isEnumClassWithMembers)(this._evaluator, baseClass)) {
-                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.enumClassOverride().format({ name: baseClass.details.name }), node.arguments[index]);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.enumClassOverride().format({ name: baseClass.shared.name }), node.d.arguments[index]);
             }
         });
     }
@@ -3342,10 +3352,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const emitBadStatementError = (node) => {
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictBadVar(), node);
         };
-        suiteNode.statements.forEach((statement) => {
+        suiteNode.d.statements.forEach((statement) => {
             if (!AnalyzerNodeInfo.isCodeUnreachable(statement)) {
                 if (statement.nodeType === 47 /* ParseNodeType.StatementList */) {
-                    for (const substatement of statement.statements) {
+                    for (const substatement of statement.d.statements) {
                         if (substatement.nodeType !== 54 /* ParseNodeType.TypeAnnotation */ &&
                             substatement.nodeType !== 21 /* ParseNodeType.Ellipsis */ &&
                             substatement.nodeType !== 48 /* ParseNodeType.StringList */ &&
@@ -3362,11 +3372,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     _validateTypeGuardFunction(node, functionType, isMethod) {
         var _a;
-        const returnType = functionType.details.declaredReturnType;
+        const returnType = functionType.shared.declaredReturnType;
         if (!returnType) {
             return;
         }
-        if (!(0, types_1.isClassInstance)(returnType) || !returnType.typeArguments || returnType.typeArguments.length < 1) {
+        if (!(0, types_1.isClassInstance)(returnType) ||
+            !returnType.priv.typeArguments ||
+            returnType.priv.typeArguments.length < 1) {
             return;
         }
         const isTypeGuard = types_1.ClassType.isBuiltIn(returnType, 'TypeGuard');
@@ -3375,7 +3387,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         // Make sure there's at least one input parameter provided.
-        let paramCount = functionType.details.parameters.length;
+        let paramCount = functionType.shared.parameters.length;
         if (isMethod) {
             if (types_1.FunctionType.isInstanceMethod(functionType) ||
                 types_1.FunctionType.isConstructorMethod(functionType) ||
@@ -3384,19 +3396,19 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
         if (paramCount < 1) {
-            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeGuardParamCount(), node.name);
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeGuardParamCount(), node.d.name);
         }
         if (isTypeIs) {
-            const typeGuardType = returnType.typeArguments[0];
+            const typeGuardType = returnType.priv.typeArguments[0];
             // Determine the type of the first parameter.
             const paramIndex = isMethod && !types_1.FunctionType.isStaticMethod(functionType) ? 1 : 0;
-            if (paramIndex >= functionType.details.parameters.length) {
+            if (paramIndex >= functionType.shared.parameters.length) {
                 return;
             }
             const paramType = types_1.FunctionType.getEffectiveParameterType(functionType, paramIndex);
             // Verify that the typeGuardType is a narrower type than the paramType.
             if (!this._evaluator.assignType(paramType, typeGuardType)) {
-                const returnAnnotation = node.returnTypeAnnotation || ((_a = node.functionAnnotationComment) === null || _a === void 0 ? void 0 : _a.returnTypeAnnotation);
+                const returnAnnotation = node.d.returnAnnotation || ((_a = node.d.funcAnnotationComment) === null || _a === void 0 ? void 0 : _a.d.returnAnnotation);
                 if (returnAnnotation) {
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeIsReturnType().format({
                         type: this._evaluator.printType(paramType),
@@ -3408,11 +3420,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     _validateDunderSignatures(node, functionType, isMethod) {
         var _a;
-        const functionName = functionType.details.name;
+        const functionName = functionType.shared.name;
         // Is this an '__init__' method? Verify that it returns None.
         if (isMethod && functionName === '__init__') {
-            const returnAnnotation = node.returnTypeAnnotation || ((_a = node.functionAnnotationComment) === null || _a === void 0 ? void 0 : _a.returnTypeAnnotation);
-            const declaredReturnType = functionType.details.declaredReturnType;
+            const returnAnnotation = node.d.returnAnnotation || ((_a = node.d.funcAnnotationComment) === null || _a === void 0 ? void 0 : _a.d.returnAnnotation);
+            const declaredReturnType = functionType.shared.declaredReturnType;
             if (returnAnnotation && declaredReturnType) {
                 if (!(0, typeUtils_1.isNoneInstance)(declaredReturnType) && !(0, types_1.isNever)(declaredReturnType)) {
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.initMustReturnNone(), returnAnnotation);
@@ -3423,7 +3435,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (!(0, types_1.isNever)(inferredReturnType) &&
                     !(0, typeUtils_1.isNoneInstance)(inferredReturnType) &&
                     !(0, types_1.isAnyOrUnknown)(inferredReturnType)) {
-                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.initMustReturnNone(), node.name);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.initMustReturnNone(), node.d.name);
                 }
             }
         }
@@ -3435,11 +3447,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (this._fileInfo.isStubFile) {
             return;
         }
-        const returnAnnotation = node.returnTypeAnnotation || ((_a = node.functionAnnotationComment) === null || _a === void 0 ? void 0 : _a.returnTypeAnnotation);
+        const returnAnnotation = node.d.returnAnnotation || ((_a = node.d.funcAnnotationComment) === null || _a === void 0 ? void 0 : _a.d.returnAnnotation);
         if (returnAnnotation) {
             const functionNeverReturns = !this._evaluator.isAfterNodeReachable(node);
-            const implicitlyReturnsNone = this._evaluator.isAfterNodeReachable(node.suite);
-            let declaredReturnType = functionType.details.declaredReturnType;
+            const implicitlyReturnsNone = this._evaluator.isAfterNodeReachable(node.d.suite);
+            let declaredReturnType = functionType.shared.declaredReturnType;
             if (declaredReturnType) {
                 this._reportUnknownReturnResult(node, declaredReturnType);
                 this._validateReturnTypeIsNotContravariant(declaredReturnType, returnAnnotation);
@@ -3456,7 +3468,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     // If the function consists entirely of "...", assume that it's
                     // an abstract method or a protocol method and don't require that
                     // the return type matches. This check can also be skipped for an overload.
-                    if (!ParseTreeUtils.isSuiteEmpty(node.suite) &&
+                    if (!ParseTreeUtils.isSuiteEmpty(node.d.suite) &&
                         !types_1.FunctionType.isOverloaded(functionType) &&
                         !types_1.FunctionType.isAsync(functionType)) {
                         this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportReturnType, localize_1.LocMessage.noReturnReturnsNone(), returnAnnotation);
@@ -3471,7 +3483,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         // If the function consists entirely of "...", assume that it's
                         // an abstract method or a protocol method and don't require that
                         // the return type matches. This check can also be skipped for an overload.
-                        if (!ParseTreeUtils.isSuiteEmpty(node.suite) && !types_1.FunctionType.isOverloaded(functionType)) {
+                        if (!ParseTreeUtils.isSuiteEmpty(node.d.suite) && !types_1.FunctionType.isOverloaded(functionType)) {
                             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportReturnType, localize_1.LocMessage.returnMissing().format({
                                 returnType: this._evaluator.printType(declaredReturnType),
                             }) + diagAddendum.getString(), returnAnnotation);
@@ -3483,15 +3495,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         else {
             const inferredReturnType = this._evaluator.getFunctionInferredReturnType(functionType);
             this._reportUnknownReturnResult(node, inferredReturnType);
-            this._validateReturnTypeIsNotContravariant(inferredReturnType, node.name);
+            this._validateReturnTypeIsNotContravariant(inferredReturnType, node.d.name);
         }
     }
     _validateReturnTypeIsNotContravariant(returnType, errorNode) {
         let isContraTypeVar = false;
         (0, typeUtils_1.doForEachSubtype)(returnType, (subtype) => {
             if ((0, types_1.isTypeVar)(subtype) &&
-                subtype.details.declaredVariance === 4 /* Variance.Contravariant */ &&
-                subtype.scopeType === 0 /* TypeVarScopeType.Class */) {
+                subtype.shared.declaredVariance === 4 /* Variance.Contravariant */ &&
+                subtype.priv.scopeType === 0 /* TypeVarScopeType.Class */) {
                 isContraTypeVar = true;
             }
         });
@@ -3501,12 +3513,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     _reportUnknownReturnResult(node, returnType) {
         if ((0, types_1.isUnknown)(returnType)) {
-            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.LocMessage.returnTypeUnknown(), node.name);
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.LocMessage.returnTypeUnknown(), node.d.name);
         }
         else if ((0, typeUtils_1.isPartlyUnknown)(returnType)) {
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.LocMessage.returnTypePartiallyUnknown().format({
                 returnType: this._evaluator.printType(returnType, { expandTypeAlias: true }),
-            }), node.name);
+            }), node.d.name);
         }
     }
     // Validates that any overridden member variables are not marked
@@ -3520,7 +3532,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     const decl = localSymbol.getDeclarations()[0];
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.finalRedeclarationBySubclass().format({
                         name,
-                        className: parentSymbol.classType.details.name,
+                        className: parentSymbol.classType.shared.name,
                     }), decl.node);
                 }
                 else if (types_1.ClassType.isReadOnlyInstanceVariables(parentSymbol.classType) &&
@@ -3531,7 +3543,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     if (decl.type === 1 /* DeclarationType.Variable */) {
                         this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.namedTupleEntryRedeclared().format({
                             name,
-                            className: parentSymbol.classType.details.name,
+                            className: parentSymbol.classType.shared.name,
                         }), decl.node);
                     }
                 }
@@ -3548,7 +3560,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const declaredValueType = (0, enums_1.getEnumDeclaredValueType)(this._evaluator, classType, /* declaredTypesOnly */ true);
         // Is there a custom "__new__" and/or "__init__" method? If so, we'll
         // verify that the signature of these calls is compatible with the values.
-        let newMemberTypeResult = (0, constructors_1.getBoundNewMethod)(this._evaluator, node.name, classType, 
+        let newMemberTypeResult = (0, constructors_1.getBoundNewMethod)(this._evaluator, node.d.name, classType, 
         /* diag */ undefined, 4 /* MemberAccessFlags.SkipObjectBaseClass */);
         // If this __new__ comes from a built-in class like Enum, we'll ignore it.
         if (newMemberTypeResult === null || newMemberTypeResult === void 0 ? void 0 : newMemberTypeResult.classType) {
@@ -3556,7 +3568,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 newMemberTypeResult = undefined;
             }
         }
-        let initMemberTypeResult = (0, constructors_1.getBoundInitMethod)(this._evaluator, node.name, types_1.ClassType.cloneAsInstance(classType), 
+        let initMemberTypeResult = (0, constructors_1.getBoundInitMethod)(this._evaluator, node.d.name, types_1.ClassType.cloneAsInstance(classType), 
         /* diag */ undefined, 4 /* MemberAccessFlags.SkipObjectBaseClass */);
         // If this __init__ comes from a built-in class like Enum, we'll ignore it.
         if (initMemberTypeResult === null || initMemberTypeResult === void 0 ? void 0 : initMemberTypeResult.classType) {
@@ -3577,7 +3589,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (!symbolType ||
                 !(0, types_1.isClassInstance)(symbolType) ||
                 !types_1.ClassType.isSameGenericClass(symbolType, classType) ||
-                !(symbolType.literalValue instanceof types_1.EnumLiteral)) {
+                !(symbolType.priv.literalValue instanceof types_1.EnumLiteral)) {
                 return;
             }
             // Enum members should not have type annotations.
@@ -3598,9 +3610,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 return;
             }
             const declNode = decls[0].node;
-            const assignedValueType = symbolType.literalValue.itemType;
+            const assignedValueType = symbolType.priv.literalValue.itemType;
             const assignmentNode = ParseTreeUtils.getParentNodeOfType(declNode, 3 /* ParseNodeType.Assignment */);
-            const errorNode = (_a = assignmentNode === null || assignmentNode === void 0 ? void 0 : assignmentNode.rightExpression) !== null && _a !== void 0 ? _a : declNode;
+            const errorNode = (_a = assignmentNode === null || assignmentNode === void 0 ? void 0 : assignmentNode.d.rightExpr) !== null && _a !== void 0 ? _a : declNode;
             // Validate the __new__ and __init__ methods if present.
             if (newMemberTypeResult || initMemberTypeResult) {
                 if (!(0, types_1.isAnyOrUnknown)(assignedValueType)) {
@@ -3618,15 +3630,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         this._evaluator.validateCallArguments(errorNode, argList, newMemberTypeResult, 
                         /* typeVarContext */ undefined, 
                         /* skipUnknownArgCheck */ undefined, 
-                        /* inferenceContext */ undefined, 
-                        /* signatureTracker */ undefined);
+                        /* inferenceContext */ undefined);
                     }
                     if (initMemberTypeResult) {
                         this._evaluator.validateCallArguments(errorNode, argList, initMemberTypeResult, 
                         /* typeVarContext */ undefined, 
                         /* skipUnknownArgCheck */ undefined, 
-                        /* inferenceContext */ undefined, 
-                        /* signatureTracker */ undefined);
+                        /* inferenceContext */ undefined);
                     }
                 }
             }
@@ -3644,7 +3654,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     // If a class is a dataclass with a `__post_init__` method, verify that its
     // signature is correct.
-    _validateDataClassPostInit(classType, errorNode) {
+    _validateDataClassPostInit(classType) {
         if (!types_1.ClassType.isDataClass(classType)) {
             return;
         }
@@ -3671,7 +3681,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const postInitType = this._evaluator.getTypeOfMember(postInitMember);
         if (!(0, types_1.isFunction)(postInitType) ||
             !types_1.FunctionType.isInstanceMethod(postInitType) ||
-            !postInitType.details.declaration) {
+            !postInitType.shared.declaration) {
             return;
         }
         const paramListDetails = (0, parameterUtils_1.getParameterListDetails)(postInitType);
@@ -3683,26 +3693,29 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         // Verify that the parameter count matches.
-        const nonDefaultParams = paramListDetails.params.filter((paramInfo) => !paramInfo.param.hasDefault);
+        const nonDefaultParams = paramListDetails.params.filter((paramInfo) => !paramInfo.param.defaultType);
         // We expect to see one param for "self" plus one for each of the InitVars.
         const expectedParamCount = initOnlySymbolMap.size + 1;
+        const postInitNode = postInitType.shared.declaration.node;
         if (expectedParamCount < nonDefaultParams.length || expectedParamCount > paramListDetails.params.length) {
-            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassPostInitParamCount().format({ expected: initOnlySymbolMap.size }), postInitType.details.declaration.node.name);
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassPostInitParamCount().format({ expected: initOnlySymbolMap.size }), postInitNode.d.name);
         }
         // Verify that the parameter types match.
         let paramIndex = 1;
         initOnlySymbolMap.forEach((symbol, fieldName) => {
-            var _a;
+            var _a, _b;
             if (paramIndex >= paramListDetails.params.length) {
                 return;
             }
             const param = paramListDetails.params[paramIndex].param;
-            if (param.hasDeclaredType && param.typeAnnotation) {
-                const fieldType = (_a = this._evaluator.getDeclaredTypeOfSymbol(symbol)) === null || _a === void 0 ? void 0 : _a.type;
+            const paramNode = postInitNode.d.params.find((node) => { var _a; return ((_a = node.d.name) === null || _a === void 0 ? void 0 : _a.d.value) === param.name; });
+            const annotationNode = (_a = paramNode === null || paramNode === void 0 ? void 0 : paramNode.d.annotation) !== null && _a !== void 0 ? _a : paramNode === null || paramNode === void 0 ? void 0 : paramNode.d.annotationComment;
+            if (types_1.FunctionParam.isTypeDeclared(param) && annotationNode) {
+                const fieldType = (_b = this._evaluator.getDeclaredTypeOfSymbol(symbol)) === null || _b === void 0 ? void 0 : _b.type;
                 const paramType = types_1.FunctionType.getEffectiveParameterType(postInitType, paramListDetails.params[paramIndex].index);
                 const assignTypeDiag = new diagnostic_1.DiagnosticAddendum();
                 if (fieldType && !this._evaluator.assignType(paramType, fieldType, assignTypeDiag)) {
-                    const diagnostic = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassPostInitType().format({ fieldName }) + assignTypeDiag.getString(), param.typeAnnotation);
+                    const diagnostic = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassPostInitType().format({ fieldName }) + assignTypeDiag.getString(), annotationNode);
                     if (diagnostic) {
                         const fieldDecls = symbol.getTypedDeclarations();
                         if (fieldDecls.length > 0) {
@@ -3737,7 +3750,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
             else if (index < errorsToDisplay) {
                 if ((0, types_1.isInstantiableClass)(abstractMethod.classType)) {
-                    const className = abstractMethod.classType.details.name;
+                    const className = abstractMethod.classType.shared.name;
                     diagAddendum.addMessage(localize_1.LocAddendum.memberIsAbstract().format({
                         type: className,
                         name: abstractMethod.symbolName,
@@ -3746,8 +3759,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         });
         this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.finalClassIsAbstract().format({
-            type: classType.details.name,
-        }) + diagAddendum.getString(), errorNode.name);
+            type: classType.shared.name,
+        }) + diagAddendum.getString(), errorNode.d.name);
     }
     // Reports the case where an instance variable is not declared or initialized
     // within the class body or constructor method.
@@ -3816,7 +3829,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         return true;
                     }
                 }
-                if (containingClass.name.value === '__init__') {
+                if (containingClass.d.name.d.value === '__init__') {
                     return true;
                 }
                 return false;
@@ -3859,12 +3872,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
             diagAddendum.addMessage(localize_1.LocAddendum.uninitializedAbstractVariable().format({
                 name,
-                classType: member.classType.details.name,
+                classType: member.classType.shared.name,
             }));
         });
         if (!diagAddendum.isEmpty()) {
-            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUninitializedInstanceVariable, localize_1.LocMessage.uninitializedAbstractVariables().format({ classType: classType.details.name }) +
-                diagAddendum.getString(), node.name);
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUninitializedInstanceVariable, localize_1.LocMessage.uninitializedAbstractVariables().format({ classType: classType.shared.name }) +
+                diagAddendum.getString(), node.d.name);
         }
     }
     // Validates that the type variables used in a generic protocol class have
@@ -3872,7 +3885,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // for an explanation for why this is important to enforce.
     _validateProtocolTypeParamVariance(errorNode, classType) {
         // If this protocol has no TypeVars with specified variance, there's nothing to do here.
-        if (classType.details.typeParameters.length === 0) {
+        if (classType.shared.typeParameters.length === 0) {
             return;
         }
         const objectType = this._evaluator.getBuiltInType(errorNode, 'object');
@@ -3881,27 +3894,27 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         const objectObject = types_1.ClassType.cloneAsInstance(objectType);
         const dummyTypeObject = types_1.ClassType.createInstantiable('__varianceDummy', '', '', uri_1.Uri.empty(), 0, 0, undefined, undefined);
-        classType.details.typeParameters.forEach((param, paramIndex) => {
+        classType.shared.typeParameters.forEach((param, paramIndex) => {
             // Skip variadics and ParamSpecs.
-            if (param.details.isVariadic || param.details.isParamSpec) {
+            if (param.shared.isVariadic || param.shared.isParamSpec) {
                 return;
             }
             // Skip type variables with auto-variance.
-            if (param.details.declaredVariance === 0 /* Variance.Auto */) {
+            if (param.shared.declaredVariance === 0 /* Variance.Auto */) {
                 return;
             }
             // Replace all type arguments with a dummy type except for the
             // TypeVar of interest, which is replaced with an object instance.
-            const srcTypeArgs = classType.details.typeParameters.map((p, i) => {
-                if (p.details.isVariadic) {
+            const srcTypeArgs = classType.shared.typeParameters.map((p, i) => {
+                if (p.shared.isVariadic) {
                     return p;
                 }
                 return i === paramIndex ? objectObject : dummyTypeObject;
             });
             // Replace all type arguments with a dummy type except for the
             // TypeVar of interest, which is replaced with itself.
-            const destTypeArgs = classType.details.typeParameters.map((p, i) => {
-                return i === paramIndex || p.details.isVariadic ? p : dummyTypeObject;
+            const destTypeArgs = classType.shared.typeParameters.map((p, i) => {
+                return i === paramIndex || p.shared.isVariadic ? p : dummyTypeObject;
             });
             const srcType = types_1.ClassType.cloneForSpecialization(classType, srcTypeArgs, /* isTypeArgumentExplicit */ true);
             const destType = types_1.ClassType.cloneForSpecialization(classType, destTypeArgs, 
@@ -3920,34 +3933,34 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     expectedVariance = 2 /* Variance.Invariant */;
                 }
             }
-            if (expectedVariance !== classType.details.typeParameters[paramIndex].details.declaredVariance) {
+            if (expectedVariance !== classType.shared.typeParameters[paramIndex].shared.declaredVariance) {
                 let message;
                 if (expectedVariance === 3 /* Variance.Covariant */) {
                     message = localize_1.LocMessage.protocolVarianceCovariant().format({
-                        variable: param.details.name,
-                        class: classType.details.name,
+                        variable: param.shared.name,
+                        class: classType.shared.name,
                     });
                 }
                 else if (expectedVariance === 4 /* Variance.Contravariant */) {
                     message = localize_1.LocMessage.protocolVarianceContravariant().format({
-                        variable: param.details.name,
-                        class: classType.details.name,
+                        variable: param.shared.name,
+                        class: classType.shared.name,
                     });
                 }
                 else {
                     message = localize_1.LocMessage.protocolVarianceInvariant().format({
-                        variable: param.details.name,
-                        class: classType.details.name,
+                        variable: param.shared.name,
+                        class: classType.shared.name,
                     });
                 }
-                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, message, errorNode.name);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, message, errorNode.d.name);
             }
         });
     }
     // Validates that a class variable doesn't conflict with a __slots__
     // name. This will generate a runtime exception.
     _validateSlotsClassVarConflict(classType) {
-        if (!classType.details.localSlotsNames) {
+        if (!classType.shared.localSlotsNames) {
             // Nothing to check, since this class doesn't use __slots__.
             return;
         }
@@ -4029,22 +4042,22 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // We'll set the "SkipArgsKwargs" flag for pragmatic reasons since __new__
         // often has an *args and/or **kwargs. We'll also set the ParamSpecValue
         // because we don't care about the return type for this check.
-        initMemberType = types_1.FunctionType.cloneWithNewFlags(initMemberType, initMemberType.details.flags | 32768 /* FunctionTypeFlags.GradualCallableForm */ | 65536 /* FunctionTypeFlags.ParamSpecValue */);
-        newMemberType = types_1.FunctionType.cloneWithNewFlags(newMemberType, initMemberType.details.flags | 32768 /* FunctionTypeFlags.GradualCallableForm */ | 65536 /* FunctionTypeFlags.ParamSpecValue */);
+        initMemberType = types_1.FunctionType.cloneWithNewFlags(initMemberType, initMemberType.shared.flags | 32768 /* FunctionTypeFlags.GradualCallableForm */ | 65536 /* FunctionTypeFlags.ParamSpecValue */);
+        newMemberType = types_1.FunctionType.cloneWithNewFlags(newMemberType, initMemberType.shared.flags | 32768 /* FunctionTypeFlags.GradualCallableForm */ | 65536 /* FunctionTypeFlags.ParamSpecValue */);
         if (!this._evaluator.assignType(newMemberType, initMemberType, 
         /* diag */ undefined, 
         /* destTypeVarContext */ undefined, 
-        /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */) ||
+        /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */) ||
             !this._evaluator.assignType(initMemberType, newMemberType, 
             /* diag */ undefined, 
             /* destTypeVarContext */ undefined, 
-            /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */)) {
+            /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */)) {
             const displayOnInit = types_1.ClassType.isSameGenericClass(initMethodResult.classType, classType);
-            const initDecl = initMemberType.details.declaration;
-            const newDecl = newMemberType.details.declaration;
+            const initDecl = initMemberType.shared.declaration;
+            const newDecl = newMemberType.shared.declaration;
             if (initDecl && newDecl) {
                 const mainDecl = displayOnInit ? initDecl : newDecl;
-                const mainDeclNode = mainDecl.node.nodeType === 31 /* ParseNodeType.Function */ ? mainDecl.node.name : mainDecl.node;
+                const mainDeclNode = mainDecl.node.nodeType === 31 /* ParseNodeType.Function */ ? mainDecl.node.d.name : mainDecl.node;
                 const diagAddendum = new diagnostic_1.DiagnosticAddendum();
                 const initSignature = this._evaluator.printType(initMemberType);
                 const newSignature = this._evaluator.printType(newMemberType);
@@ -4072,7 +4085,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // Skip this check if the class has only one base class or one or more
         // of the base classes are Any.
         const filteredBaseClasses = [];
-        for (const baseClass of classType.details.baseClasses) {
+        for (const baseClass of classType.shared.baseClasses) {
             if (!(0, types_1.isClass)(baseClass)) {
                 return;
             }
@@ -4086,12 +4099,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const diagAddendum = new diagnostic_1.DiagnosticAddendum();
         for (const baseClass of filteredBaseClasses) {
             const typeVarContext = (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(baseClass);
-            for (const baseClassMroClass of baseClass.details.mro) {
+            for (const baseClassMroClass of baseClass.shared.mro) {
                 // There's no need to check for conflicts if this class isn't generic.
-                if ((0, types_1.isClass)(baseClassMroClass) && baseClassMroClass.details.typeParameters.length > 0) {
+                if ((0, types_1.isClass)(baseClassMroClass) && baseClassMroClass.shared.typeParameters.length > 0) {
                     const specializedBaseClassMroClass = (0, typeUtils_1.applySolvedTypeVars)(baseClassMroClass, typeVarContext);
                     // Find the corresponding class in the derived class's MRO list.
-                    const matchingMroClass = classType.details.mro.find((mroClass) => (0, types_1.isClass)(mroClass) && types_1.ClassType.isSameGenericClass(mroClass, specializedBaseClassMroClass));
+                    const matchingMroClass = classType.shared.mro.find((mroClass) => (0, types_1.isClass)(mroClass) && types_1.ClassType.isSameGenericClass(mroClass, specializedBaseClassMroClass));
                     if (matchingMroClass && (0, types_1.isInstantiableClass)(matchingMroClass)) {
                         const matchingMroObject = types_1.ClassType.cloneAsInstance(matchingMroClass);
                         const baseClassMroObject = types_1.ClassType.cloneAsInstance(specializedBaseClassMroClass);
@@ -4120,7 +4133,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
         if (!diagAddendum.isEmpty()) {
-            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.baseClassIncompatible().format({ type: classType.details.name }) + diagAddendum.getString(), errorNode);
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.baseClassIncompatible().format({ type: classType.shared.name }) + diagAddendum.getString(), errorNode);
         }
     }
     // Validates that any methods and variables in multiple base classes are
@@ -4135,7 +4148,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const baseClasses = [];
         // Filter any unknown base classes. Also remove Generic and Protocol
         // base classes.
-        classType.details.baseClasses.forEach((baseClass) => {
+        classType.shared.baseClasses.forEach((baseClass) => {
             if ((0, types_1.isClass)(baseClass) &&
                 !types_1.ClassType.isBuiltIn(baseClass, 'Generic') &&
                 !types_1.ClassType.isBuiltIn(baseClass, 'Protocol')) {
@@ -4148,7 +4161,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         // Build maps of symbols for each of the base classes.
         const baseClassSymbolMaps = baseClasses.map((baseClass) => {
-            const specializedBaseClass = classType.details.mro.find((c) => (0, types_1.isClass)(c) && types_1.ClassType.isSameGenericClass(c, baseClass));
+            const specializedBaseClass = classType.shared.mro.find((c) => (0, types_1.isClass)(c) && types_1.ClassType.isSameGenericClass(c, baseClass));
             if (!specializedBaseClass || !(0, types_1.isClass)(specializedBaseClass)) {
                 return new Map();
             }
@@ -4195,10 +4208,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         let overriddenType = this._evaluator.getEffectiveTypeOfSymbol(overriddenClassAndSymbol.symbol);
-        overriddenType = (0, typeUtils_1.partiallySpecializeType)(overriddenType, overriddenClassAndSymbol.classType);
+        overriddenType = (0, typeUtils_1.partiallySpecializeType)(overriddenType, overriddenClassAndSymbol.classType, this._evaluator.getTypeClassType());
         const overrideSymbol = overrideClassAndSymbol.symbol;
         let overrideType = this._evaluator.getEffectiveTypeOfSymbol(overrideSymbol);
-        overrideType = (0, typeUtils_1.partiallySpecializeType)(overrideType, overrideClassAndSymbol.classType);
+        overrideType = (0, typeUtils_1.partiallySpecializeType)(overrideType, overrideClassAndSymbol.classType, this._evaluator.getTypeClassType());
         const childOverrideSymbol = types_1.ClassType.getSymbolTable(childClassType).get(memberName);
         const childOverrideType = childOverrideSymbol
             ? this._evaluator.getEffectiveTypeOfSymbol(childOverrideSymbol)
@@ -4224,10 +4237,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (!this._evaluator.validateOverrideMethod(overriddenType, overrideFunction, 
                 /* baseClass */ undefined, diagAddendum, 
                 /* enforceParamNameMatch */ true)) {
-                    const decl = overrideFunction.details.declaration;
+                    const decl = overrideFunction.shared.declaration;
                     if (decl && decl.type === 5 /* DeclarationType.Function */) {
                         diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.baseClassMethodTypeIncompatible().format({
-                            classType: childClassType.details.name,
+                            classType: childClassType.shared.name,
                             name: memberName,
                         }) + diagAddendum.getString(), errorNode);
                     }
@@ -4240,7 +4253,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 const decls = overrideSymbol.getDeclarations();
                 if (decls.length > 0) {
                     diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.baseClassVariableTypeIncompatible().format({
-                        classType: childClassType.details.name,
+                        classType: childClassType.shared.name,
                         name: memberName,
                     }), errorNode);
                 }
@@ -4258,31 +4271,31 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 // If the entry is a member of a frozen dataclass, it is immutable,
                 // so it does not need to be invariant.
                 if (types_1.ClassType.isDataClassFrozen(overriddenClassAndSymbol.classType) &&
-                    overriddenClassAndSymbol.classType.details.dataClassEntries) {
-                    const dataclassEntry = overriddenClassAndSymbol.classType.details.dataClassEntries.find((entry) => entry.name === memberName);
+                    overriddenClassAndSymbol.classType.shared.dataClassEntries) {
+                    const dataclassEntry = overriddenClassAndSymbol.classType.shared.dataClassEntries.find((entry) => entry.name === memberName);
                     if (dataclassEntry) {
                         isInvariant = false;
                     }
                 }
                 let overriddenTDEntry;
-                if (overriddenClassAndSymbol.classType.details.typedDictEntries) {
+                if (overriddenClassAndSymbol.classType.shared.typedDictEntries) {
                     overriddenTDEntry =
-                        (_b = (_a = overriddenClassAndSymbol.classType.details.typedDictEntries.knownItems.get(memberName)) !== null && _a !== void 0 ? _a : overriddenClassAndSymbol.classType.details.typedDictEntries.extraItems) !== null && _b !== void 0 ? _b : (0, typedDicts_1.getEffectiveExtraItemsEntryType)(this._evaluator, overriddenClassAndSymbol.classType);
+                        (_b = (_a = overriddenClassAndSymbol.classType.shared.typedDictEntries.knownItems.get(memberName)) !== null && _a !== void 0 ? _a : overriddenClassAndSymbol.classType.shared.typedDictEntries.extraItems) !== null && _b !== void 0 ? _b : (0, typedDicts_1.getEffectiveExtraItemsEntryType)(this._evaluator, overriddenClassAndSymbol.classType);
                     if (overriddenTDEntry === null || overriddenTDEntry === void 0 ? void 0 : overriddenTDEntry.isReadOnly) {
                         isInvariant = false;
                     }
                 }
                 let overrideTDEntry;
-                if (overrideClassAndSymbol.classType.details.typedDictEntries) {
+                if (overrideClassAndSymbol.classType.shared.typedDictEntries) {
                     overrideTDEntry =
-                        (_d = (_c = overrideClassAndSymbol.classType.details.typedDictEntries.knownItems.get(memberName)) !== null && _c !== void 0 ? _c : overrideClassAndSymbol.classType.details.typedDictEntries.extraItems) !== null && _d !== void 0 ? _d : (0, typedDicts_1.getEffectiveExtraItemsEntryType)(this._evaluator, overrideClassAndSymbol.classType);
+                        (_d = (_c = overrideClassAndSymbol.classType.shared.typedDictEntries.knownItems.get(memberName)) !== null && _c !== void 0 ? _c : overrideClassAndSymbol.classType.shared.typedDictEntries.extraItems) !== null && _d !== void 0 ? _d : (0, typedDicts_1.getEffectiveExtraItemsEntryType)(this._evaluator, overrideClassAndSymbol.classType);
                 }
                 if (!this._evaluator.assignType(overriddenType, childOverrideType !== null && childOverrideType !== void 0 ? childOverrideType : overrideType, 
                 /* diag */ undefined, 
                 /* destTypeVarContext */ undefined, 
                 /* srcTypeVarContext */ undefined, isInvariant ? 1 /* AssignTypeFlags.EnforceInvariance */ : 0 /* AssignTypeFlags.Default */)) {
                     diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.baseClassVariableTypeIncompatible().format({
-                        classType: childClassType.details.name,
+                        classType: childClassType.shared.name,
                         name: memberName,
                     }), errorNode);
                 }
@@ -4328,9 +4341,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     _validateMultipleInheritancePropertyOverride(overriddenClassType, overrideClassType, overriddenSymbolType, overrideSymbolType, overrideSymbol, memberName, errorNode) {
         const propMethodInfo = [
-            ['fget', (c) => { var _a; return (_a = c.fgetInfo) === null || _a === void 0 ? void 0 : _a.methodType; }],
-            ['fset', (c) => { var _a; return (_a = c.fsetInfo) === null || _a === void 0 ? void 0 : _a.methodType; }],
-            ['fdel', (c) => { var _a; return (_a = c.fdelInfo) === null || _a === void 0 ? void 0 : _a.methodType; }],
+            ['fget', (c) => { var _a; return (_a = c.priv.fgetInfo) === null || _a === void 0 ? void 0 : _a.methodType; }],
+            ['fset', (c) => { var _a; return (_a = c.priv.fsetInfo) === null || _a === void 0 ? void 0 : _a.methodType; }],
+            ['fdel', (c) => { var _a; return (_a = c.priv.fdelInfo) === null || _a === void 0 ? void 0 : _a.methodType; }],
         ];
         propMethodInfo.forEach((info) => {
             const diagAddendum = new diagnostic_1.DiagnosticAddendum();
@@ -4339,7 +4352,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const subclassPropMethod = methodAccessor(overrideSymbolType);
             // Is the method present on the base class but missing in the subclass?
             if (baseClassPropMethod) {
-                const baseClassMethodType = (0, typeUtils_1.partiallySpecializeType)(baseClassPropMethod, overriddenClassType);
+                const baseClassMethodType = (0, typeUtils_1.partiallySpecializeType)(baseClassPropMethod, overriddenClassType, this._evaluator.getTypeClassType());
                 if ((0, types_1.isFunction)(baseClassMethodType)) {
                     if (!subclassPropMethod) {
                         // The method is missing.
@@ -4351,28 +4364,28 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             const lastDecl = decls[decls.length - 1];
                             const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.propertyOverridden().format({
                                 name: memberName,
-                                className: overriddenClassType.details.name,
+                                className: overriddenClassType.shared.name,
                             }) + diagAddendum.getString(), errorNode);
-                            const origDecl = baseClassMethodType.details.declaration;
+                            const origDecl = baseClassMethodType.shared.declaration;
                             if (diag && origDecl) {
                                 this._addMultipleInheritanceRelatedInfo(diag, overriddenClassType, overriddenSymbolType, origDecl, overrideClassType, overrideSymbolType, lastDecl);
                             }
                         }
                     }
                     else {
-                        const subclassMethodType = (0, typeUtils_1.partiallySpecializeType)(subclassPropMethod, overrideClassType);
+                        const subclassMethodType = (0, typeUtils_1.partiallySpecializeType)(subclassPropMethod, overrideClassType, this._evaluator.getTypeClassType());
                         if ((0, types_1.isFunction)(subclassMethodType)) {
                             if (!this._evaluator.validateOverrideMethod(baseClassMethodType, subclassMethodType, overrideClassType, diagAddendum.createAddendum())) {
                                 diagAddendum.addMessage(localize_1.LocAddendum.propertyMethodIncompatible().format({
                                     name: methodName,
                                 }));
-                                const decl = subclassMethodType.details.declaration;
+                                const decl = subclassMethodType.shared.declaration;
                                 if (decl && decl.type === 5 /* DeclarationType.Function */) {
                                     const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.propertyOverridden().format({
                                         name: memberName,
-                                        className: overriddenClassType.details.name,
+                                        className: overriddenClassType.shared.name,
                                     }) + diagAddendum.getString(), errorNode);
-                                    const origDecl = baseClassMethodType.details.declaration;
+                                    const origDecl = baseClassMethodType.shared.declaration;
                                     if (diag && origDecl) {
                                         this._addMultipleInheritanceRelatedInfo(diag, overriddenClassType, overriddenSymbolType, origDecl, overrideClassType, overrideSymbolType, decl);
                                     }
@@ -4407,10 +4420,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (!types_1.FunctionType.isFinal(implementation)) {
                     overloads.forEach((overload) => {
                         var _a, _b;
-                        if (types_1.FunctionType.isFinal(overload) && ((_a = overload.details.declaration) === null || _a === void 0 ? void 0 : _a.node)) {
+                        if (types_1.FunctionType.isFinal(overload) && ((_a = overload.shared.declaration) === null || _a === void 0 ? void 0 : _a.node)) {
                             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadFinalInconsistencyImpl().format({
-                                name: overload.details.name,
-                            }), (_b = (0, declarationUtils_1.getNameNodeForDeclaration)(overload.details.declaration)) !== null && _b !== void 0 ? _b : overload.details.declaration.node);
+                                name: overload.shared.name,
+                            }), (_b = (0, declarationUtils_1.getNameNodeForDeclaration)(overload.shared.declaration)) !== null && _b !== void 0 ? _b : overload.shared.declaration.node);
                         }
                     });
                 }
@@ -4419,11 +4432,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (!types_1.FunctionType.isFinal(overloads[0])) {
                 overloads.slice(1).forEach((overload, index) => {
                     var _a, _b;
-                    if (types_1.FunctionType.isFinal(overload) && ((_a = overload.details.declaration) === null || _a === void 0 ? void 0 : _a.node)) {
+                    if (types_1.FunctionType.isFinal(overload) && ((_a = overload.shared.declaration) === null || _a === void 0 ? void 0 : _a.node)) {
                         this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadFinalInconsistencyNoImpl().format({
-                            name: overload.details.name,
+                            name: overload.shared.name,
                             index: index + 2,
-                        }), (_b = (0, declarationUtils_1.getNameNodeForDeclaration)(overload.details.declaration)) !== null && _b !== void 0 ? _b : overload.details.declaration.node);
+                        }), (_b = (0, declarationUtils_1.getNameNodeForDeclaration)(overload.shared.declaration)) !== null && _b !== void 0 ? _b : overload.shared.declaration.node);
                     }
                 });
             }
@@ -4437,7 +4450,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         const typedDictEntries = (0, typedDicts_1.getTypedDictMembersForClass)(this._evaluator, classType, /* allowNarrowed */ false);
-        for (const baseClass of classType.details.baseClasses) {
+        for (const baseClass of classType.shared.baseClasses) {
             const diag = new diagnostic_1.DiagnosticAddendum();
             if (!(0, types_1.isClass)(baseClass) ||
                 !types_1.ClassType.isTypedDictClass(baseClass) ||
@@ -4489,18 +4502,18 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }));
                 }
             }
-            if (!diag.isEmpty() && classType.details.declaration) {
-                const declNode = (0, declarationUtils_1.getNameNodeForDeclaration)(classType.details.declaration);
+            if (!diag.isEmpty() && classType.shared.declaration) {
+                const declNode = (0, declarationUtils_1.getNameNodeForDeclaration)(classType.shared.declaration);
                 if (declNode) {
                     if (baseTypedDictEntries.extraItems) {
                         this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.typedDictClosedExtras().format({
-                            name: baseClass.details.name,
+                            name: baseClass.shared.name,
                             type: this._evaluator.printType(baseExtraItemsType),
                         }) + diag.getString(), declNode);
                     }
                     else {
                         this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.typedDictClosedNoExtras().format({
-                            name: baseClass.details.name,
+                            name: baseClass.shared.name,
                         }) + diag.getString(), declNode);
                     }
                 }
@@ -4532,13 +4545,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 return;
             }
             let firstOverride;
-            for (const baseClass of classType.details.baseClasses) {
+            for (const baseClass of classType.shared.baseClasses) {
                 if (!(0, types_1.isClass)(baseClass)) {
                     continue;
                 }
                 // Look up the base class in the MRO list. It's the same generic class
                 // but has already been specialized using the type variables of the classType.
-                const mroBaseClass = classType.details.mro.find((mroClass) => (0, types_1.isClass)(mroClass) && types_1.ClassType.isSameGenericClass(mroClass, baseClass));
+                const mroBaseClass = classType.shared.mro.find((mroClass) => (0, types_1.isClass)(mroClass) && types_1.ClassType.isSameGenericClass(mroClass, baseClass));
                 if (!mroBaseClass) {
                     continue;
                 }
@@ -4573,31 +4586,31 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             overrideFunction = types_1.OverloadedFunctionType.getImplementation(overrideType);
         }
         else if ((0, types_1.isClassInstance)(overrideType) && types_1.ClassType.isPropertyClass(overrideType)) {
-            if (overrideType.fgetInfo) {
-                overrideFunction = overrideType.fgetInfo.methodType;
+            if (overrideType.priv.fgetInfo) {
+                overrideFunction = overrideType.priv.fgetInfo.methodType;
             }
         }
-        if (!(overrideFunction === null || overrideFunction === void 0 ? void 0 : overrideFunction.details.declaration) || types_1.FunctionType.isOverridden(overrideFunction)) {
+        if (!(overrideFunction === null || overrideFunction === void 0 ? void 0 : overrideFunction.shared.declaration) || types_1.FunctionType.isOverridden(overrideFunction)) {
             return;
         }
         // Constructors are exempt.
-        if (this._isMethodExemptFromLsp(overrideFunction.details.name)) {
+        if (this._isMethodExemptFromLsp(overrideFunction.shared.name)) {
             return;
         }
         // If the declaration for the override function is not the same as the
         // declaration for the symbol, the function was probably replaced by a decorator.
-        if (!symbol.getDeclarations().some((decl) => decl === overrideFunction.details.declaration)) {
+        if (!symbol.getDeclarations().some((decl) => decl === overrideFunction.shared.declaration)) {
             return;
         }
         // If the base class is unknown, don't report a missing decorator.
         if ((0, types_1.isAnyOrUnknown)(baseMember.classType)) {
             return;
         }
-        const funcNode = overrideFunction.details.declaration.node;
+        const funcNode = overrideFunction.shared.declaration.node;
         this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportImplicitOverride, localize_1.LocMessage.overrideDecoratorMissing().format({
-            name: funcNode.name.value,
+            name: funcNode.d.name.d.value,
             className: this._evaluator.printType((0, typeUtils_1.convertToInstance)(baseMember.classType)),
-        }), funcNode.name);
+        }), funcNode.d.name);
     }
     // Determines whether the name is exempt from Liskov Substitution Principle rules.
     _isMethodExemptFromLsp(name) {
@@ -4616,20 +4629,20 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             overrideFunction = types_1.OverloadedFunctionType.getImplementation(overrideType);
         }
         else if ((0, types_1.isClassInstance)(overrideType) && types_1.ClassType.isPropertyClass(overrideType)) {
-            if (overrideType.fgetInfo) {
-                overrideFunction = overrideType.fgetInfo.methodType;
+            if (overrideType.priv.fgetInfo) {
+                overrideFunction = overrideType.priv.fgetInfo.methodType;
             }
         }
-        if (!(overrideFunction === null || overrideFunction === void 0 ? void 0 : overrideFunction.details.declaration) || !types_1.FunctionType.isOverridden(overrideFunction)) {
+        if (!(overrideFunction === null || overrideFunction === void 0 ? void 0 : overrideFunction.shared.declaration) || !types_1.FunctionType.isOverridden(overrideFunction)) {
             return;
         }
         // If the declaration for the override function is not the same as the
         // declaration for the symbol, the function was probably replaced by a decorator.
-        if (!symbol.getDeclarations().some((decl) => decl === overrideFunction.details.declaration)) {
+        if (!symbol.getDeclarations().some((decl) => decl === overrideFunction.shared.declaration)) {
             return;
         }
-        const funcNode = overrideFunction.details.declaration.node;
-        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.overriddenMethodNotFound().format({ name: funcNode.name.value }), funcNode.name);
+        const funcNode = overrideFunction.shared.declaration.node;
+        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.overriddenMethodNotFound().format({ name: funcNode.d.name.d.value }), funcNode.d.name);
     }
     _validateBaseClassOverride(baseClassAndSymbol, overrideSymbol, overrideType, childClassType, memberName) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
@@ -4652,8 +4665,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         const baseClass = baseClassAndSymbol.classType;
         const childClassSelf = types_1.ClassType.cloneAsInstance((0, typeUtils_1.selfSpecializeClass)(childClassType));
-        const baseType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(baseClassAndSymbol.symbol), baseClass, childClassSelf);
-        overrideType = (0, typeUtils_1.partiallySpecializeType)(overrideType, childClassType, childClassSelf);
+        const baseType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(baseClassAndSymbol.symbol), baseClass, this._evaluator.getTypeClassType(), childClassSelf);
+        overrideType = (0, typeUtils_1.partiallySpecializeType)(overrideType, childClassType, this._evaluator.getTypeClassType(), childClassSelf);
         if ((0, types_1.isFunction)(baseType) || (0, types_1.isOverloadedFunction)(baseType)) {
             const diagAddendum = new diagnostic_1.DiagnosticAddendum();
             // Determine whether this is an attempt to override a method marked @final.
@@ -4664,7 +4677,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     reportFinalMethodOverride = true;
                 }
                 else if ((0, types_1.isOverloadedFunction)(baseType) &&
-                    baseType.overloads.some((overload) => types_1.FunctionType.isFinal(overload))) {
+                    baseType.priv.overloads.some((overload) => types_1.FunctionType.isFinal(overload))) {
                     reportFinalMethodOverride = true;
                 }
             }
@@ -4673,8 +4686,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (decl && decl.type === 5 /* DeclarationType.Function */) {
                     const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.finalMethodOverride().format({
                         name: memberName,
-                        className: baseClass.details.name,
-                    }), decl.node.name);
+                        className: baseClass.shared.name,
+                    }), decl.node.d.name);
                     const origDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(baseClassAndSymbol.symbol);
                     if (diag && origDecl) {
                         diag.addRelatedInfo(localize_1.LocAddendum.finalMethod(), origDecl.uri, origDecl.range);
@@ -4694,13 +4707,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     !SymbolNameUtils.isPrivateName(memberName) &&
                     !types_1.ClassType.isTypedDictClass(childClassType)) {
                     if (!this._evaluator.validateOverrideMethod(baseType, overrideType, childClassType, diagAddendum, enforceParamNameMatch)) {
-                        const decl = (0, types_1.isFunction)(overrideType) && overrideType.details.declaration
-                            ? overrideType.details.declaration
+                        const decl = (0, types_1.isFunction)(overrideType) && overrideType.shared.declaration
+                            ? overrideType.shared.declaration
                             : (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(overrideSymbol);
                         if (decl) {
                             const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.incompatibleMethodOverride().format({
                                 name: memberName,
-                                className: baseClass.details.name,
+                                className: baseClass.shared.name,
                             }) + diagAddendum.getString(), (_a = (0, declarationUtils_1.getNameNodeForDeclaration)(decl)) !== null && _a !== void 0 ? _a : decl.node);
                             const origDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(baseClassAndSymbol.symbol);
                             if (diag && origDecl) {
@@ -4720,7 +4733,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         const lastDecl = decls[decls.length - 1];
                         const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.methodOverridden().format({
                             name: memberName,
-                            className: baseClass.details.name,
+                            className: baseClass.shared.name,
                             type: this._evaluator.printType(overrideType),
                         }), (_b = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _b !== void 0 ? _b : lastDecl.node);
                         const origDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(baseClassAndSymbol.symbol);
@@ -4739,7 +4752,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     const lastDecl = decls[decls.length - 1];
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.propertyOverridden().format({
                         name: memberName,
-                        className: baseClass.details.name,
+                        className: baseClass.shared.name,
                     }), (_c = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _c !== void 0 ? _c : lastDecl.node);
                 }
             }
@@ -4760,8 +4773,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     let isInvariant = (primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 1 /* DeclarationType.Variable */ && !primaryDecl.isFinal;
                     // If the entry is a member of a frozen dataclass, it is immutable,
                     // so it does not need to be invariant.
-                    if (types_1.ClassType.isDataClassFrozen(baseClass) && baseClass.details.dataClassEntries) {
-                        const dataclassEntry = baseClass.details.dataClassEntries.find((entry) => entry.name === memberName);
+                    if (types_1.ClassType.isDataClassFrozen(baseClass) && baseClass.shared.dataClassEntries) {
+                        const dataclassEntry = baseClass.shared.dataClassEntries.find((entry) => entry.name === memberName);
                         if (dataclassEntry) {
                             isInvariant = false;
                         }
@@ -4769,14 +4782,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     let overriddenTDEntry;
                     let overrideTDEntry;
                     if (!overrideSymbol.isIgnoredForProtocolMatch()) {
-                        if (baseClass.details.typedDictEntries) {
+                        if (baseClass.shared.typedDictEntries) {
                             overriddenTDEntry =
-                                (_e = (_d = baseClass.details.typedDictEntries.knownItems.get(memberName)) !== null && _d !== void 0 ? _d : baseClass.details.typedDictEntries.extraItems) !== null && _e !== void 0 ? _e : (0, typedDicts_1.getEffectiveExtraItemsEntryType)(this._evaluator, baseClass);
+                                (_e = (_d = baseClass.shared.typedDictEntries.knownItems.get(memberName)) !== null && _d !== void 0 ? _d : baseClass.shared.typedDictEntries.extraItems) !== null && _e !== void 0 ? _e : (0, typedDicts_1.getEffectiveExtraItemsEntryType)(this._evaluator, baseClass);
                             if (overriddenTDEntry === null || overriddenTDEntry === void 0 ? void 0 : overriddenTDEntry.isReadOnly) {
                                 isInvariant = false;
                             }
                         }
-                        if (childClassType.details.typedDictEntries) {
+                        if (childClassType.shared.typedDictEntries) {
                             // Exempt __extra_items__ here. We'll check this separately
                             // in _validateTypedDictOverrides. If we don't skip it here,
                             // redundant errors will be produced.
@@ -4786,7 +4799,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             }
                             else {
                                 overrideTDEntry =
-                                    (_g = (_f = childClassType.details.typedDictEntries.knownItems.get(memberName)) !== null && _f !== void 0 ? _f : childClassType.details.typedDictEntries.extraItems) !== null && _g !== void 0 ? _g : (0, typedDicts_1.getEffectiveExtraItemsEntryType)(this._evaluator, childClassType);
+                                    (_g = (_f = childClassType.shared.typedDictEntries.knownItems.get(memberName)) !== null && _f !== void 0 ? _f : childClassType.shared.typedDictEntries.extraItems) !== null && _g !== void 0 ? _g : (0, typedDicts_1.getEffectiveExtraItemsEntryType)(this._evaluator, childClassType);
                             }
                         }
                     }
@@ -4804,7 +4817,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                         const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.symbolOverridden().format({
                             name: memberName,
-                            className: baseClass.details.name,
+                            className: baseClass.shared.name,
                         }) + diagAddendum.getString(), (_h = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _h !== void 0 ? _h : lastDecl.node);
                         const origDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(baseClassAndSymbol.symbol);
                         if (diag && origDecl) {
@@ -4842,7 +4855,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     if (!isBaseVarFinal && overrideFinalVarDecl) {
                         const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.variableFinalOverride().format({
                             name: memberName,
-                            className: baseClass.details.name,
+                            className: baseClass.shared.name,
                         }), (_l = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _l !== void 0 ? _l : lastDecl.node);
                         if (diag) {
                             diag.addRelatedInfo(localize_1.LocAddendum.overriddenSymbol(), overrideFinalVarDecl.uri, overrideFinalVarDecl.range);
@@ -4874,7 +4887,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             : localize_1.LocMessage.instanceVarOverridesClassVar();
                         const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, unformattedMessage.format({
                             name: memberName,
-                            className: baseClass.details.name,
+                            className: baseClass.shared.name,
                         }), (_m = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _m !== void 0 ? _m : lastDecl.node);
                         const origDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(baseClassAndSymbol.symbol);
                         if (diag && origDecl) {
@@ -4887,9 +4900,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     _validatePropertyOverride(baseClassType, childClassType, baseType, childType, overrideSymbol, memberName) {
         const propMethodInfo = [
-            ['fget', (c) => { var _a; return (_a = c.fgetInfo) === null || _a === void 0 ? void 0 : _a.methodType; }],
-            ['fset', (c) => { var _a; return (_a = c.fsetInfo) === null || _a === void 0 ? void 0 : _a.methodType; }],
-            ['fdel', (c) => { var _a; return (_a = c.fdelInfo) === null || _a === void 0 ? void 0 : _a.methodType; }],
+            ['fget', (c) => { var _a; return (_a = c.priv.fgetInfo) === null || _a === void 0 ? void 0 : _a.methodType; }],
+            ['fset', (c) => { var _a; return (_a = c.priv.fsetInfo) === null || _a === void 0 ? void 0 : _a.methodType; }],
+            ['fdel', (c) => { var _a; return (_a = c.priv.fdelInfo) === null || _a === void 0 ? void 0 : _a.methodType; }],
         ];
         propMethodInfo.forEach((info) => {
             var _a;
@@ -4899,7 +4912,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const subclassPropMethod = methodAccessor(childType);
             // Is the method present on the base class but missing in the subclass?
             if (baseClassPropMethod) {
-                const baseClassMethodType = (0, typeUtils_1.partiallySpecializeType)(baseClassPropMethod, baseClassType);
+                const baseClassMethodType = (0, typeUtils_1.partiallySpecializeType)(baseClassPropMethod, baseClassType, this._evaluator.getTypeClassType());
                 if ((0, types_1.isFunction)(baseClassMethodType)) {
                     if (!subclassPropMethod) {
                         // The method is missing.
@@ -4911,28 +4924,28 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             const lastDecl = decls[decls.length - 1];
                             const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.propertyOverridden().format({
                                 name: memberName,
-                                className: baseClassType.details.name,
+                                className: baseClassType.shared.name,
                             }) + diagAddendum.getString(), (_a = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _a !== void 0 ? _a : lastDecl.node);
-                            const origDecl = baseClassMethodType.details.declaration;
+                            const origDecl = baseClassMethodType.shared.declaration;
                             if (diag && origDecl) {
                                 diag.addRelatedInfo(localize_1.LocAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
                             }
                         }
                     }
                     else {
-                        const subclassMethodType = (0, typeUtils_1.partiallySpecializeType)(subclassPropMethod, childClassType);
+                        const subclassMethodType = (0, typeUtils_1.partiallySpecializeType)(subclassPropMethod, childClassType, this._evaluator.getTypeClassType());
                         if ((0, types_1.isFunction)(subclassMethodType)) {
                             if (!this._evaluator.validateOverrideMethod(baseClassMethodType, subclassMethodType, childClassType, diagAddendum.createAddendum())) {
                                 diagAddendum.addMessage(localize_1.LocAddendum.propertyMethodIncompatible().format({
                                     name: methodName,
                                 }));
-                                const decl = subclassMethodType.details.declaration;
+                                const decl = subclassMethodType.shared.declaration;
                                 if (decl && decl.type === 5 /* DeclarationType.Function */) {
                                     const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.propertyOverridden().format({
                                         name: memberName,
-                                        className: baseClassType.details.name,
-                                    }) + diagAddendum.getString(), decl.node.name);
-                                    const origDecl = baseClassMethodType.details.declaration;
+                                        className: baseClassType.shared.name,
+                                    }) + diagAddendum.getString(), decl.node.d.name);
+                                    const origDecl = baseClassMethodType.shared.declaration;
                                     if (diag && origDecl) {
                                         diag.addRelatedInfo(localize_1.LocAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
                                     }
@@ -4950,9 +4963,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         var _a, _b;
         const classTypeInfo = this._evaluator.getTypeOfClass(classNode);
         const classType = classTypeInfo === null || classTypeInfo === void 0 ? void 0 : classTypeInfo.classType;
-        if (node.name && classType) {
+        if (node.d.name && classType) {
             const superCheckMethods = ['__init__', '__init_subclass__', '__enter__', '__exit__'];
-            if (superCheckMethods.some((name) => name === node.name.value)) {
+            if (superCheckMethods.some((name) => name === node.d.name.d.value)) {
                 if (!types_1.FunctionType.isAbstractMethod(functionType) &&
                     !types_1.FunctionType.isOverloaded(functionType) &&
                     !this._fileInfo.isStubFile) {
@@ -4960,48 +4973,48 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             }
         }
-        if (((_a = node.name) === null || _a === void 0 ? void 0 : _a.value) === '__new__') {
+        if (((_a = node.d.name) === null || _a === void 0 ? void 0 : _a.d.value) === '__new__') {
             // __new__ overrides should have a "cls" parameter.
-            if (node.parameters.length === 0 ||
-                !node.parameters[0].name ||
-                !['cls', '_cls', '__cls', '__mcls', 'mcls', 'mcs', 'metacls'].some((name) => node.parameters[0].name.value === name)) {
-                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.LocMessage.newClsParam(), node.parameters.length > 0 ? node.parameters[0] : node.name);
+            if (node.d.params.length === 0 ||
+                !node.d.params[0].d.name ||
+                !['cls', '_cls', '__cls', '__mcls', 'mcls', 'mcs', 'metacls'].some((name) => node.d.params[0].d.name.d.value === name)) {
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.LocMessage.newClsParam(), node.d.params.length > 0 ? node.d.params[0] : node.d.name);
             }
             if (classType) {
-                this._validateClsSelfParameterType(functionType, classType, /* isCls */ true);
+                this._validateClsSelfParameterType(node, functionType, classType, /* isCls */ true);
             }
         }
-        else if (((_b = node.name) === null || _b === void 0 ? void 0 : _b.value) === '_generate_next_value_') {
+        else if (((_b = node.d.name) === null || _b === void 0 ? void 0 : _b.d.value) === '_generate_next_value_') {
             // Skip this check for _generate_next_value_.
         }
         else if (types_1.FunctionType.isStaticMethod(functionType)) {
             // Static methods should not have "self" or "cls" parameters.
-            if (node.parameters.length > 0 && node.parameters[0].name) {
-                const paramName = node.parameters[0].name.value;
+            if (node.d.params.length > 0 && node.d.params[0].d.name) {
+                const paramName = node.d.params[0].d.name.d.value;
                 if (paramName === 'self' || paramName === 'cls') {
-                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.LocMessage.staticClsSelfParam(), node.parameters[0].name);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.LocMessage.staticClsSelfParam(), node.d.params[0].d.name);
                 }
             }
         }
         else if (types_1.FunctionType.isClassMethod(functionType)) {
             let paramName = '';
-            if (node.parameters.length > 0 && node.parameters[0].name) {
-                paramName = node.parameters[0].name.value;
+            if (node.d.params.length > 0 && node.d.params[0].d.name) {
+                paramName = node.d.params[0].d.name.d.value;
             }
             // Class methods should have a "cls" parameter. We'll exempt parameter
             // names that start with an underscore since those are used in a few
             // cases in the stdlib pyi files.
             if (paramName !== 'cls') {
                 if (!this._fileInfo.isStubFile || (!paramName.startsWith('_') && paramName !== 'metacls')) {
-                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.LocMessage.classMethodClsParam(), node.parameters.length > 0 ? node.parameters[0] : node.name);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.LocMessage.classMethodClsParam(), node.d.params.length > 0 ? node.d.params[0] : node.d.name);
                 }
             }
             if (classType) {
-                this._validateClsSelfParameterType(functionType, classType, /* isCls */ true);
+                this._validateClsSelfParameterType(node, functionType, classType, /* isCls */ true);
             }
         }
         else {
-            const decoratorIsPresent = node.decorators.length > 0;
+            const decoratorIsPresent = node.d.decorators.length > 0;
             const isOverloaded = types_1.FunctionType.isOverloaded(functionType);
             // The presence of a decorator can change the behavior, so we need
             // to back off from this check if a decorator is present. An overload
@@ -5009,11 +5022,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (isOverloaded || !decoratorIsPresent) {
                 let paramName = '';
                 let firstParamIsSimple = true;
-                if (node.parameters.length > 0) {
-                    if (node.parameters[0].name) {
-                        paramName = node.parameters[0].name.value;
+                if (node.d.params.length > 0) {
+                    if (node.d.params[0].d.name) {
+                        paramName = node.d.params[0].d.name.d.value;
                     }
-                    if (node.parameters[0].category !== 0 /* ParameterCategory.Simple */) {
+                    if (node.d.params[0].d.category !== 0 /* ParameterCategory.Simple */) {
                         firstParamIsSimple = false;
                     }
                 }
@@ -5037,12 +5050,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     // a parameter that cannot be positional.
                     const isPrivateName = SymbolNameUtils.isPrivateOrProtectedName(paramName);
                     if (!isLegalMetaclassName && !isPrivateName) {
-                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.LocMessage.instanceMethodSelfParam(), node.parameters.length > 0 ? node.parameters[0] : node.name);
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.LocMessage.instanceMethodSelfParam(), node.d.params.length > 0 ? node.d.params[0] : node.d.name);
                     }
                 }
             }
             if (classType) {
-                this._validateClsSelfParameterType(functionType, classType, /* isCls */ false);
+                this._validateClsSelfParameterType(node, functionType, classType, /* isCls */ false);
             }
         }
     }
@@ -5063,7 +5076,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (types_1.ClassType.isFinal(classType)) {
             effectiveFlags |= 4 /* MemberAccessFlags.SkipObjectBaseClass */;
         }
-        const methodMember = (0, typeUtils_1.lookUpClassMember)(classType, methodType.details.name, effectiveFlags);
+        const methodMember = (0, typeUtils_1.lookUpClassMember)(classType, methodType.shared.name, effectiveFlags);
         if (!methodMember) {
             return;
         }
@@ -5071,14 +5084,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // Now scan the implementation of the method to determine whether
         // super().<method> has been called for all of the required base classes.
         const callNodeWalker = new ParseTreeUtils.CallNodeWalker((node) => {
-            if (node.leftExpression.nodeType === 35 /* ParseNodeType.MemberAccess */) {
+            if (node.d.leftExpr.nodeType === 35 /* ParseNodeType.MemberAccess */) {
                 // Is it accessing the method by the same name?
-                if (node.leftExpression.memberName.value === methodType.details.name) {
-                    const memberBaseExpr = node.leftExpression.leftExpression;
+                if (node.d.leftExpr.d.member.d.value === methodType.shared.name) {
+                    const memberBaseExpr = node.d.leftExpr.d.leftExpr;
                     // Is it a "super" call?
                     if (memberBaseExpr.nodeType === 9 /* ParseNodeType.Call */ &&
-                        memberBaseExpr.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
-                        memberBaseExpr.leftExpression.value === 'super') {
+                        memberBaseExpr.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ &&
+                        memberBaseExpr.d.leftExpr.d.value === 'super') {
                         foundCallOfMember = true;
                     }
                     else {
@@ -5091,33 +5104,35 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             }
         });
-        callNodeWalker.walk(node.suite);
+        callNodeWalker.walk(node.d.suite);
         // If we didn't find a call to at least one base class, report the problem.
         if (!foundCallOfMember) {
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportMissingSuperCall, localize_1.LocMessage.missingSuperCall().format({
-                methodName: methodType.details.name,
-            }), node.name);
+                methodName: methodType.shared.name,
+            }), node.d.name);
         }
     }
     // Validates that the annotated type of a "self" or "cls" parameter is
     // compatible with the type of the class that contains it.
-    _validateClsSelfParameterType(functionType, classType, isCls) {
-        if (functionType.details.parameters.length < 1) {
+    _validateClsSelfParameterType(node, functionType, classType, isCls) {
+        var _a;
+        if (node.d.params.length < 1 || functionType.shared.parameters.length < 1) {
             return;
         }
         // If there is no type annotation, there's nothing to check because
-        // the type will be inferred.
-        const paramInfo = functionType.details.parameters[0];
-        if (!paramInfo.typeAnnotation || !paramInfo.name) {
+        // the type will be inferred.d.typeAnnotation
+        const paramInfo = functionType.shared.parameters[0];
+        const paramAnnotation = (_a = node.d.params[0].d.annotation) !== null && _a !== void 0 ? _a : node.d.params[0].d.annotationComment;
+        if (!paramAnnotation || !paramInfo.name) {
             return;
         }
         // If this is an __init__ method, we need to specifically check for the
         // use of class-scoped TypeVars, which are not allowed in this context
         // according to the typing spec.
-        if (functionType.details.name === '__init__' && functionType.details.methodClass) {
+        if (functionType.shared.name === '__init__' && functionType.shared.methodClass) {
             const typeVars = (0, typeUtils_1.getTypeVarArgumentsRecursive)(paramInfo.type);
-            if (typeVars.some((typeVar) => { var _a; return typeVar.scopeId === ((_a = functionType.details.methodClass) === null || _a === void 0 ? void 0 : _a.details.typeVarScopeId); })) {
-                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, localize_1.LocMessage.initMethodSelfParamTypeVar(), paramInfo.typeAnnotation);
+            if (typeVars.some((typeVar) => { var _a; return typeVar.priv.scopeId === ((_a = functionType.shared.methodClass) === null || _a === void 0 ? void 0 : _a.shared.typeVarScopeId); })) {
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, localize_1.LocMessage.initMethodSelfParamTypeVar(), paramAnnotation);
             }
         }
         // If this is a protocol class, the self and cls parameters can be bound
@@ -5138,7 +5153,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // If the method starts with a `*args: P.args`, skip the check.
         if (paramInfo.category === 1 /* ParameterCategory.ArgsList */ &&
             (0, types_1.isParamSpec)(paramInfo.type) &&
-            paramInfo.type.paramSpecAccess === 'args') {
+            paramInfo.type.priv.paramSpecAccess === 'args') {
             return;
         }
         // Don't enforce this for an overloaded method because the "self" param
@@ -5162,7 +5177,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.clsSelfParamTypeMismatch().format({
                     name: paramInfo.name,
                     classType: this._evaluator.printType(expectedType),
-                }), paramInfo.typeAnnotation);
+                }), paramAnnotation);
             }
         }
     }
@@ -5171,19 +5186,21 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     _validateYieldType(node, yieldType, expectedDiagAddendum, sendType) {
         var _a, _b, _c, _d;
         const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(node);
-        if (!enclosingFunctionNode || !enclosingFunctionNode.returnTypeAnnotation) {
+        if (!enclosingFunctionNode || !enclosingFunctionNode.d.returnAnnotation) {
             return;
         }
         const functionTypeResult = this._evaluator.getTypeOfFunction(enclosingFunctionNode);
         if (!functionTypeResult) {
             return;
         }
-        const declaredReturnType = types_1.FunctionType.getEffectiveReturnType(functionTypeResult.functionType);
+        let declaredReturnType = types_1.FunctionType.getEffectiveReturnType(functionTypeResult.functionType);
         if (!declaredReturnType) {
             return;
         }
+        const liveScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
+        declaredReturnType = (0, typeUtils_1.updateTypeWithInternalTypeVars)(declaredReturnType, liveScopes);
         let generatorType;
-        if (!enclosingFunctionNode.isAsync &&
+        if (!enclosingFunctionNode.d.isAsync &&
             (0, types_1.isClassInstance)(declaredReturnType) &&
             types_1.ClassType.isBuiltIn(declaredReturnType, 'AwaitableGenerator')) {
             // Handle the old-style (pre-await) generator case
@@ -5191,7 +5208,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             generatorType = this._evaluator.getTypingType(node, 'AwaitableGenerator');
         }
         else {
-            generatorType = this._evaluator.getTypingType(node, enclosingFunctionNode.isAsync ? 'AsyncGenerator' : 'Generator');
+            generatorType = this._evaluator.getTypingType(node, enclosingFunctionNode.d.isAsync ? 'AsyncGenerator' : 'Generator');
         }
         if (!generatorType || !(0, types_1.isInstantiableClass)(generatorType)) {
             return;
@@ -5207,11 +5224,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const specializedGenerator = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(generatorType, generatorTypeArgs, /* isTypeArgumentExplicit */ true));
         const diagAddendum = new diagnostic_1.DiagnosticAddendum();
         if (!this._evaluator.assignType(declaredReturnType, specializedGenerator, diagAddendum)) {
-            const errorMessage = enclosingFunctionNode.isAsync
+            const errorMessage = enclosingFunctionNode.d.isAsync
                 ? localize_1.LocMessage.generatorAsyncReturnType()
                 : localize_1.LocMessage.generatorSyncReturnType();
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportReturnType, errorMessage.format({ yieldType: this._evaluator.printType(yieldType) }) +
-                ((_a = expectedDiagAddendum === null || expectedDiagAddendum === void 0 ? void 0 : expectedDiagAddendum.getString()) !== null && _a !== void 0 ? _a : diagAddendum.getString()), (_b = node.expression) !== null && _b !== void 0 ? _b : node, (_d = (_c = expectedDiagAddendum === null || expectedDiagAddendum === void 0 ? void 0 : expectedDiagAddendum.getEffectiveTextRange()) !== null && _c !== void 0 ? _c : node.expression) !== null && _d !== void 0 ? _d : node);
+                ((_a = expectedDiagAddendum === null || expectedDiagAddendum === void 0 ? void 0 : expectedDiagAddendum.getString()) !== null && _a !== void 0 ? _a : diagAddendum.getString()), (_b = node.d.expr) !== null && _b !== void 0 ? _b : node, (_d = (_c = expectedDiagAddendum === null || expectedDiagAddendum === void 0 ? void 0 : expectedDiagAddendum.getEffectiveTextRange()) !== null && _c !== void 0 ? _c : node.d.expr) !== null && _d !== void 0 ? _d : node);
         }
     }
     // Determines whether any of the except statements are unreachable because
@@ -5219,12 +5236,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     _reportUnusedExceptStatements(node) {
         let sawUnknownExceptionType = false;
         const exceptionTypesSoFar = [];
-        node.exceptClauses.forEach((except) => {
+        node.d.exceptClauses.forEach((except) => {
             var _a, _b;
-            if (sawUnknownExceptionType || except.isExceptGroup || !except.typeExpression) {
+            if (sawUnknownExceptionType || except.d.isExceptGroup || !except.d.typeExpr) {
                 return;
             }
-            const exceptionType = this._evaluator.getType(except.typeExpression);
+            const exceptionType = this._evaluator.getType(except.d.typeExpr);
             if (!exceptionType || (0, types_1.isAnyOrUnknown)(exceptionType)) {
                 sawUnknownExceptionType = true;
                 return;
@@ -5233,7 +5250,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if ((0, types_1.isInstantiableClass)(exceptionType)) {
                 // If the exception type is a variable whose type could represent
                 // subclasses, the actual exception type is statically unknown.
-                if (exceptionType.includeSubclasses) {
+                if (exceptionType.priv.includeSubclasses) {
                     sawUnknownExceptionType = true;
                 }
                 typesOfThisExcept.push(exceptionType);
@@ -5241,7 +5258,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             else if ((0, types_1.isClassInstance)(exceptionType)) {
                 const iterableType = (_b = (_a = this._evaluator.getTypeOfIterator({ type: exceptionType }, 
                 /* isAsync */ false, 
-                /* errorNode */ except.typeExpression, 
+                /* errorNode */ except.d.typeExpr, 
                 /* emitNotIterableError */ false)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
                 (0, typeUtils_1.doForEachSubtype)(iterableType, (subtype) => {
                     if ((0, types_1.isAnyOrUnknown)(subtype)) {
@@ -5250,7 +5267,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     if ((0, types_1.isInstantiableClass)(subtype)) {
                         // If the exception type is a variable whose type could represent
                         // subclasses, the actual exception type is statically unknown.
-                        if (subtype.includeSubclasses) {
+                        if (subtype.priv.includeSubclasses) {
                             sawUnknownExceptionType = true;
                         }
                         typesOfThisExcept.push(subtype);
@@ -5277,8 +5294,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 });
                 // Were all of the exception types overridden?
                 if (typesOfThisExcept.length > 0 && typesOfThisExcept.length === overriddenExceptionCount) {
-                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnusedExcept, localize_1.LocMessage.unreachableExcept() + diagAddendum.getString(), except.typeExpression);
-                    this._evaluator.addUnreachableCode(except, except.exceptSuite);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnusedExcept, localize_1.LocMessage.unreachableExcept() + diagAddendum.getString(), except.d.typeExpr);
+                    this._evaluator.addUnreachableCode(except, except.d.exceptSuite);
                 }
             }
             (0, collectionUtils_1.appendArray)(exceptionTypesSoFar, typesOfThisExcept);
@@ -5290,22 +5307,22 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         importStatements.orderedImports.forEach((importStatement) => {
             if (importStatement.node.nodeType === 25 /* ParseNodeType.ImportFrom */) {
                 const symbolMap = new Map();
-                importStatement.node.imports.forEach((importFromAs) => {
+                importStatement.node.d.imports.forEach((importFromAs) => {
                     // Ignore duplicates if they're aliased.
-                    if (!importFromAs.alias) {
-                        const prevImport = symbolMap.get(importFromAs.name.value);
+                    if (!importFromAs.d.alias) {
+                        const prevImport = symbolMap.get(importFromAs.d.name.d.value);
                         if (prevImport) {
-                            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportDuplicateImport, localize_1.LocMessage.duplicateImport().format({ importName: importFromAs.name.value }), importFromAs.name);
+                            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportDuplicateImport, localize_1.LocMessage.duplicateImport().format({ importName: importFromAs.d.name.d.value }), importFromAs.d.name);
                         }
                         else {
-                            symbolMap.set(importFromAs.name.value, importFromAs);
+                            symbolMap.set(importFromAs.d.name.d.value, importFromAs);
                         }
                     }
                 });
             }
             else if (importStatement.subnode) {
                 // Ignore duplicates if they're aliased.
-                if (!importStatement.subnode.alias) {
+                if (!importStatement.subnode.d.alias) {
                     const prevImport = importModuleMap.get(importStatement.moduleName);
                     if (prevImport) {
                         this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportDuplicateImport, localize_1.LocMessage.duplicateImport().format({ importName: importStatement.moduleName }), importStatement.subnode);