@zzzen/pyright-internal 1.2.0-dev.20231231 → 1.2.0-dev.20240114

package/dist/analyzer/checker.js

@@ -60,6 +60,7 @@ const parameterUtils_1 = require("./parameterUtils");
 const ParseTreeUtils = __importStar(require("./parseTreeUtils"));
 const parseTreeWalker_1 = require("./parseTreeWalker");
 const patternMatching_1 = require("./patternMatching");
+const protocols_1 = require("./protocols");
 const regions_1 = require("./regions");
 const scopeUtils_1 = require("./scopeUtils");
 const sourceFile_1 = require("./sourceFile");
@@ -162,8 +163,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             !types_1.ClassType.isBuiltIn(baseClassType, 'Generic')) {
                             if (!types_1.ClassType.isProtocolClass(baseClassType)) {
                                 this._evaluator.addError(localize_1.Localizer.Diagnostic.protocolBaseClass().format({
-                                    classType: this._evaluator.printType(classTypeResult.classType),
-                                    baseType: this._evaluator.printType(baseClassType),
+                                    classType: classTypeResult.classType.details.name,
+                                    baseType: baseClassType.details.name,
                                 }), arg.valueExpression);
                             }
                         }
@@ -179,6 +180,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 this._validateSlotsClassVarConflict(classTypeResult.classType);
             }
             this._validateBaseClassOverrides(classTypeResult.classType);
+            this._validateOverloadDecoratorConsistency(classTypeResult.classType);
             this._validateMultipleInheritanceBaseClasses(classTypeResult.classType, node.name);
             this._validateMultipleInheritanceCompatibility(classTypeResult.classType, node.name);
             this._validateConstructorConsistency(classTypeResult.classType, node.name);
@@ -1952,6 +1954,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)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
                 resultingExceptionType = (0, typeUtils_1.mapSubtypes)(iterableType, (subtype) => {
+                    subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
                     if ((0, types_1.isAnyOrUnknown)(subtype) || (0, types_1.isNever)(subtype)) {
                         return subtype;
                     }
@@ -2546,6 +2549,26 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     type: this._evaluator.printType(arg1Type),
                 }) + diag.getString(), node.arguments[1]);
         }
+        // If this call is an issubclass, check for the use of a "data protocol",
+        // which PEP 544 says cannot be used in issubclass.
+        if (!isInstanceCheck) {
+            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) {
+                    arg1Subtype.tupleTypeArguments.forEach((typeArg) => {
+                        this._validateNotDataProtocol(typeArg.type, diag);
+                    });
+                }
+                else {
+                    this._validateNotDataProtocol(arg1Subtype, diag);
+                }
+            });
+            if (!diag.isEmpty()) {
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.dataProtocolInSubclassCheck(), node.arguments[1]);
+            }
+        }
         // If this call is within an assert statement, we won't check whether
         // it's unnecessary.
         let curNode = node;
@@ -2581,6 +2604,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             arg1IncludesSubclasses = true;
                         }
                     }
+                    if (arg0Type) {
+                        this._validateUnsafeProtocolOverlap(node.arguments[0].valueExpression, (0, typeUtils_1.convertToInstance)(arg1Subtype), isInstanceCheck ? arg0Type : (0, typeUtils_1.convertToInstance)(arg0Type));
+                    }
                 }
                 else {
                     // The isinstance and issubclass call supports a variation where the second
@@ -2593,6 +2619,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                                     if (typeArg.type.includeSubclasses) {
                                         arg1IncludesSubclasses = true;
                                     }
+                                    if (arg0Type) {
+                                        this._validateUnsafeProtocolOverlap(node.arguments[0].valueExpression, (0, typeUtils_1.convertToInstance)(typeArg.type), isInstanceCheck ? arg0Type : (0, typeUtils_1.convertToInstance)(arg0Type));
+                                    }
                                 }
                                 else {
                                     isValidType = false;
@@ -2706,6 +2735,29 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }), node);
         }
     }
+    _validateUnsafeProtocolOverlap(errorNode, protocol, testType) {
+        // If this is a protocol class, check for an "unsafe overlap"
+        // with the arg0 type.
+        if (types_1.ClassType.isProtocolClass(protocol)) {
+            let isUnsafeOverlap = false;
+            const diag = new diagnostic_1.DiagnosticAddendum();
+            (0, typeUtils_1.doForEachSubtype)(testType, (testSubtype) => {
+                if ((0, types_1.isClassInstance)(testSubtype)) {
+                    if ((0, protocols_1.isProtocolUnsafeOverlap)(this._evaluator, protocol, testSubtype)) {
+                        isUnsafeOverlap = true;
+                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.protocolUnsafeOverlap().format({
+                            name: testSubtype.details.name,
+                        }));
+                    }
+                }
+            });
+            if (isUnsafeOverlap) {
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.protocolUnsafeOverlap().format({
+                    name: protocol.details.name,
+                }) + diag.getString(), errorNode);
+            }
+        }
+    }
     // Determines whether the specified type is allowed as the second argument
     // to an isinstance or issubclass check.
     _isTypeSupportedTypeForIsInstance(type, isInstanceCheck, diag) {
@@ -2713,6 +2765,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
             subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
             subtype = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(subtype);
+            if (subtype.specialForm && types_1.ClassType.isBuiltIn(subtype.specialForm, 'TypeAliasType')) {
+                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAliasInstanceCheck());
+                isSupported = false;
+                return;
+            }
             switch (subtype.category) {
                 case 2 /* TypeCategory.Any */:
                 case 1 /* TypeCategory.Unknown */:
@@ -2761,6 +2818,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         });
         return isSupported;
     }
+    _validateNotDataProtocol(type, diag) {
+        if ((0, types_1.isInstantiableClass)(type) && types_1.ClassType.isProtocolClass(type) && !(0, protocols_1.isMethodOnlyProtocol)(type)) {
+            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.dataProtocolUnsupported().format({
+                name: type.details.name,
+            }));
+        }
+    }
     _isSymbolPrivate(nameValue, scopeType) {
         // All variables within the scope of a function or a list
         // comprehension are considered private.
@@ -3396,14 +3460,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                 }
                 else if (decls[0].type === 5 /* DeclarationType.Function */) {
-                    if (decls.every((decl) => decl.type !== 5 /* DeclarationType.Function */ || ParseTreeUtils.isSuiteEmpty(decl.node.suite))) {
-                        if (!decls[0].uri.hasExtension('.pyi')) {
-                            if (!isSymbolImplemented(name)) {
-                                diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.missingProtocolMember().format({
-                                    name,
-                                    classType: member.classType.details.name,
-                                }));
-                            }
+                    if (this._isUnimplementedProtocolMethod(member.symbol)) {
+                        if (!isSymbolImplemented(name)) {
+                            diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.missingProtocolMember().format({
+                                name,
+                                classType: member.classType.details.name,
+                            }));
                         }
                     }
                 }
@@ -3485,6 +3547,42 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             paramIndex++;
         });
     }
+    // Determine whether a method defined in a protocol should be considered
+    // "unimplemented". This is an under-specified part of the typing spec.
+    _isUnimplementedProtocolMethod(symbol) {
+        const symbolType = this._evaluator.getEffectiveTypeOfSymbol(symbol);
+        // Behavior differs between stub files and source files.
+        const decls = symbol.getDeclarations();
+        const isDeclaredInStubFile = decls.length > 0 && (0, sourceMapper_1.isStubFile)(decls[0].uri);
+        if ((0, types_1.isFunction)(symbolType)) {
+            const decl = symbolType.details.declaration;
+            if (decl) {
+                return isDeclaredInStubFile
+                    ? types_1.FunctionType.isAbstractMethod(symbolType)
+                    : ParseTreeUtils.isSuiteEmpty(decl.node.suite);
+            }
+        }
+        else if ((0, types_1.isOverloadedFunction)(symbolType)) {
+            // If an implementation is present and has an empty body, assume
+            // the function is unimplemented.
+            const impl = types_1.OverloadedFunctionType.getImplementation(symbolType);
+            if (impl) {
+                const decl = impl.details.declaration;
+                if (decl) {
+                    return ParseTreeUtils.isSuiteEmpty(decl.node.suite);
+                }
+                return false;
+            }
+            if (isDeclaredInStubFile) {
+                // If no implementation was present, see if any of the overloads
+                // are marked as abstract.
+                const overloads = types_1.OverloadedFunctionType.getOverloads(symbolType);
+                return overloads.some((overload) => types_1.FunctionType.isAbstractMethod(overload));
+            }
+            return true;
+        }
+        return false;
+    }
     // If a class is marked final, it must implement all abstract methods,
     // otherwise it is of no use.
     _validateFinalClassNotAbstract(classType, errorNode) {
@@ -4094,6 +4192,51 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }), overrideDecl.uri, overrideDecl.range);
         }
     }
+    // Validates that any overloaded methods are consistent in how they
+    // are decorated. For example, if the first overload is not marked @final
+    // but subsequent ones are, an error should be reported.
+    _validateOverloadDecoratorConsistency(classType) {
+        classType.details.fields.forEach((symbol, name) => {
+            const primaryDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
+            if (!primaryDecl || primaryDecl.type !== 5 /* DeclarationType.Function */) {
+                return;
+            }
+            const typeOfSymbol = this._evaluator.getEffectiveTypeOfSymbol(symbol);
+            if (!(0, types_1.isOverloadedFunction)(typeOfSymbol)) {
+                return;
+            }
+            const overloads = types_1.OverloadedFunctionType.getOverloads(typeOfSymbol);
+            // If there's an implementation, it will determine whether the
+            // function is @final.
+            const implementation = types_1.OverloadedFunctionType.getImplementation(typeOfSymbol);
+            if (implementation) {
+                // If one or more of the overloads is marked @final but the
+                // implementation is not, report an error.
+                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)) {
+                            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overloadFinalInconsistencyImpl().format({
+                                name: overload.details.name,
+                            }), (_b = (0, declarationUtils_1.getNameNodeForDeclaration)(overload.details.declaration)) !== null && _b !== void 0 ? _b : overload.details.declaration.node);
+                        }
+                    });
+                }
+                return;
+            }
+            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)) {
+                        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overloadFinalInconsistencyNoImpl().format({
+                            name: overload.details.name,
+                            index: index + 2,
+                        }), (_b = (0, declarationUtils_1.getNameNodeForDeclaration)(overload.details.declaration)) !== null && _b !== void 0 ? _b : overload.details.declaration.node);
+                    }
+                });
+            }
+        });
+    }
     // Validates that any overridden methods or variables contain the same
     // types as the original method. Also marks the class as abstract if one
     // or more abstract methods are not overridden.
@@ -4213,7 +4356,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overriddenMethodNotFound().format({ name: funcNode.name.value }), funcNode.name);
     }
     _validateBaseClassOverride(baseClassAndSymbol, overrideSymbol, overrideType, childClassType, memberName) {
-        var _a, _b;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         if (!(0, types_1.isInstantiableClass)(baseClassAndSymbol.classType)) {
             return;
         }
@@ -4237,6 +4380,31 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         overrideType = (0, typeUtils_1.partiallySpecializeType)(overrideType, childClassType, 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.
+            let reportFinalMethodOverride = false;
+            // Private names (starting with double underscore) are exempt from this check.
+            if (!SymbolNameUtils.isPrivateName(memberName)) {
+                if ((0, types_1.isFunction)(baseType) && types_1.FunctionType.isFinal(baseType)) {
+                    reportFinalMethodOverride = true;
+                }
+                else if ((0, types_1.isOverloadedFunction)(baseType) &&
+                    baseType.overloads.some((overload) => types_1.FunctionType.isFinal(overload))) {
+                    reportFinalMethodOverride = true;
+                }
+            }
+            if (reportFinalMethodOverride) {
+                const decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(overrideSymbol);
+                if (decl && decl.type === 5 /* DeclarationType.Function */) {
+                    const diag = this._evaluator.addError(localize_1.Localizer.Diagnostic.finalMethodOverride().format({
+                        name: memberName,
+                        className: baseClass.details.name,
+                    }), decl.node.name);
+                    const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
+                    if (diag && origDecl) {
+                        diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.finalMethod(), origDecl.uri, origDecl.range);
+                    }
+                }
+            }
             if ((0, types_1.isFunction)(overrideType) || (0, types_1.isOverloadedFunction)(overrideType)) {
                 // Don't enforce parameter names for dundered methods. Many of them
                 // are misnamed in typeshed stubs, so this would result in many
@@ -4257,7 +4425,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.incompatibleMethodOverride().format({
                                 name: memberName,
                                 className: baseClass.details.name,
-                            }) + diagAddendum.getString(), decl.type === 5 /* DeclarationType.Function */ ? decl.node.name : decl.node);
+                            }) + diagAddendum.getString(), (_a = (0, declarationUtils_1.getNameNodeForDeclaration)(decl)) !== null && _a !== void 0 ? _a : decl.node);
                             const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
                             if (diag && origDecl) {
                                 diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
@@ -4265,22 +4433,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                     }
                 }
-                if ((0, types_1.isFunction)(baseType)) {
-                    // Private names (starting with double underscore) are exempt from this check.
-                    if (!SymbolNameUtils.isPrivateName(memberName) && types_1.FunctionType.isFinal(baseType)) {
-                        const decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(overrideSymbol);
-                        if (decl && decl.type === 5 /* DeclarationType.Function */) {
-                            const diag = this._evaluator.addError(localize_1.Localizer.Diagnostic.finalMethodOverride().format({
-                                name: memberName,
-                                className: baseClass.details.name,
-                            }), decl.node.name);
-                            const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
-                            if (diag && origDecl) {
-                                diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.finalMethod(), origDecl.uri, origDecl.range);
-                            }
-                        }
-                    }
-                }
             }
             else if (!(0, types_1.isAnyOrUnknown)(overrideType)) {
                 // Special-case overrides of methods in '_TypedDict', since
@@ -4294,7 +4446,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             name: memberName,
                             className: baseClass.details.name,
                             type: this._evaluator.printType(overrideType),
-                        }), lastDecl.node);
+                        }), (_b = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _b !== void 0 ? _b : lastDecl.node);
                         const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
                         if (diag && origDecl) {
                             diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
@@ -4308,10 +4460,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (!(0, typeUtils_1.isProperty)(overrideType)) {
                 const decls = overrideSymbol.getDeclarations();
                 if (decls.length > 0) {
+                    const lastDecl = decls[decls.length - 1];
                     this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.propertyOverridden().format({
                         name: memberName,
                         className: baseClass.details.name,
-                    }), decls[decls.length - 1].node);
+                    }), (_c = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _c !== void 0 ? _c : lastDecl.node);
                 }
             }
             else {
@@ -4322,6 +4475,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     ['fdel', (c) => { var _a; return (_a = c.fdelInfo) === null || _a === void 0 ? void 0 : _a.methodType; }],
                 ];
                 propMethodInfo.forEach((info) => {
+                    var _a;
                     const diagAddendum = new diagnostic_1.DiagnosticAddendum();
                     const [methodName, methodAccessor] = info;
                     const baseClassPropMethod = methodAccessor(baseType);
@@ -4337,10 +4491,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                                 }));
                                 const decls = overrideSymbol.getDeclarations();
                                 if (decls.length > 0) {
+                                    const lastDecl = decls[decls.length - 1];
                                     const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.propertyOverridden().format({
                                         name: memberName,
                                         className: baseClassType.details.name,
-                                    }) + diagAddendum.getString(), decls[decls.length - 1].node);
+                                    }) + diagAddendum.getString(), (_a = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _a !== void 0 ? _a : lastDecl.node);
                                     const origDecl = baseClassMethodType.details.declaration;
                                     if (diag && origDecl) {
                                         diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
@@ -4418,7 +4573,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.Localizer.Diagnostic.symbolOverridden().format({
                             name: memberName,
                             className: baseClass.details.name,
-                        }) + diagAddendum.getString(), (_a = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _a !== void 0 ? _a : lastDecl.node);
+                        }) + diagAddendum.getString(), (_d = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _d !== void 0 ? _d : lastDecl.node);
                         const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
                         if (diag && origDecl) {
                             diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenSymbol(), origDecl.uri, origDecl.range);
@@ -4439,14 +4594,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             const message = overrideTDEntry.isRequired
                                 ? localize_1.Localizer.Diagnostic.typedDictFieldRequiredRedefinition
                                 : localize_1.Localizer.Diagnostic.typedDictFieldNotRequiredRedefinition;
-                            this._evaluator.addDiagnostic(AnalyzerNodeInfo.getFileInfo(lastDecl.node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message().format({ name: memberName }), lastDecl.node);
+                            this._evaluator.addDiagnostic(AnalyzerNodeInfo.getFileInfo(lastDecl.node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message().format({ name: memberName }), (_e = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _e !== void 0 ? _e : lastDecl.node);
                         }
                         // Make sure that the derived class isn't marking a previously writable
                         // entry as read-only.
                         if (!overriddenTDEntry.isReadOnly && overrideTDEntry.isReadOnly) {
                             this._evaluator.addDiagnostic(AnalyzerNodeInfo.getFileInfo(lastDecl.node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typedDictFieldReadOnlyRedefinition().format({
                                 name: memberName,
-                            }), lastDecl.node);
+                            }), (_f = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _f !== void 0 ? _f : lastDecl.node);
                         }
                     }
                     // Verify that there is not a Final mismatch.
@@ -4456,7 +4611,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.Localizer.Diagnostic.variableFinalOverride().format({
                             name: memberName,
                             className: baseClass.details.name,
-                        }), lastDecl.node);
+                        }), (_g = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _g !== void 0 ? _g : lastDecl.node);
                         if (diag) {
                             diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenSymbol(), overrideFinalVarDecl.uri, overrideFinalVarDecl.range);
                         }
@@ -4485,7 +4640,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, unformattedMessage.format({
                             name: memberName,
                             className: baseClass.details.name,
-                        }), (_b = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _b !== void 0 ? _b : lastDecl.node);
+                        }), (_h = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _h !== void 0 ? _h : lastDecl.node);
                         const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
                         if (diag && origDecl) {
                             diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenSymbol(), origDecl.uri, origDecl.range);