@zzzen/pyright-internal 1.2.0-dev.20231126 → 1.2.0-dev.20231210

package/dist/analyzer/checker.js

@@ -42,9 +42,9 @@ const collectionUtils_1 = require("../common/collectionUtils");
 const debug_1 = require("../common/debug");
 const diagnostic_1 = require("../common/diagnostic");
 const diagnosticRules_1 = require("../common/diagnosticRules");
-const pathUtils_1 = require("../common/pathUtils");
 const pythonVersion_1 = require("../common/pythonVersion");
 const textRange_1 = require("../common/textRange");
+const uri_1 = require("../common/uri/uri");
 const definitionProvider_1 = require("../languageService/definitionProvider");
 const localize_1 = require("../localization/localize");
 const parseNodes_1 = require("../parser/parseNodes");
@@ -98,7 +98,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // Report code complexity issues for the module.
         const codeComplexity = AnalyzerNodeInfo.getCodeFlowComplexity(this._moduleNode);
         if (isPrintCodeComplexityEnabled) {
-            console.log(`Code complexity of module ${this._fileInfo.filePath} is ${codeComplexity.toString()}`);
+            console.log(`Code complexity of module ${this._fileInfo.fileUri.toUserVisibleString()} is ${codeComplexity.toString()}`);
         }
         if (codeComplexity > typeEvaluator_1.maxCodeComplexity) {
             this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.codeTooComplexToAnalyze(), { start: 0, length: 0 });
@@ -385,6 +385,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._validateTypeGuardFunction(node, functionTypeResult.functionType, containingClassNode !== undefined);
             this._validateFunctionTypeVarUsage(node, functionTypeResult);
             this._validateGeneratorReturnType(node, functionTypeResult.functionType);
+            this._reportDeprecatedClassProperty(node, functionTypeResult);
         }
         // 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.
@@ -412,6 +413,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                 }
             }
+            this._validateOverloadAttributeConsistency(node, functionTypeResult.decoratedType);
         }
         return false;
     }
@@ -531,7 +533,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitReturn(node) {
-        var _a, _b;
+        var _a, _b, _c, _d, _e;
         let returnTypeResult;
         const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(node);
         const declaredReturnType = enclosingFunctionNode
@@ -600,17 +602,17 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.returnTypeMismatch().format({
                             exprType: this._evaluator.printType(returnTypeResult.type),
                             returnType: this._evaluator.printType(declaredReturnType),
-                        }) + diagAddendum.getString(), node.returnExpression ? node.returnExpression : node, (_b = returnTypeResult.expectedTypeDiagAddendum) === null || _b === void 0 ? void 0 : _b.getEffectiveTextRange());
+                        }) + diagAddendum.getString(), (_b = node.returnExpression) !== null && _b !== void 0 ? _b : node, (_c = returnTypeResult.expectedTypeDiagAddendum) === null || _c === void 0 ? void 0 : _c.getEffectiveTextRange());
                     }
                 }
             }
             if ((0, types_1.isUnknown)(returnTypeResult.type)) {
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.Localizer.Diagnostic.returnTypeUnknown(), node.returnExpression);
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.Localizer.Diagnostic.returnTypeUnknown(), (_d = node.returnExpression) !== null && _d !== void 0 ? _d : node);
             }
             else if ((0, typeUtils_1.isPartlyUnknown)(returnTypeResult.type)) {
                 this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.Localizer.Diagnostic.returnTypePartiallyUnknown().format({
                     returnType: this._evaluator.printType(returnTypeResult.type, { expandTypeAlias: true }),
-                }), node.returnExpression);
+                }), (_e = node.returnExpression) !== null && _e !== void 0 ? _e : node);
             }
         }
         return true;
@@ -992,10 +994,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 continue;
             }
             const resolvedAlias = this._evaluator.resolveAliasDeclaration(decl, /* resolveLocalNames */ true);
-            if (!(resolvedAlias === null || resolvedAlias === void 0 ? void 0 : resolvedAlias.path) || !(0, sourceMapper_1.isStubFile)(resolvedAlias.path)) {
+            const resolvedAliasUri = resolvedAlias === null || resolvedAlias === void 0 ? void 0 : resolvedAlias.uri;
+            if (!resolvedAliasUri || !(0, sourceMapper_1.isStubFile)(resolvedAliasUri)) {
                 continue;
             }
-            const importResult = this._getImportResult(node, resolvedAlias.path);
+            const importResult = this._getImportResult(node, resolvedAliasUri);
             if (!importResult) {
                 continue;
             }
@@ -1030,6 +1033,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     visitTypeParameter(node) {
         return false;
     }
+    visitTypeAlias(node) {
+        const scope = (0, scopeUtils_1.getScopeForNode)(node);
+        if (scope) {
+            if (scope.type !== 2 /* ScopeType.Class */ && scope.type !== 3 /* ScopeType.Module */ && scope.type !== 4 /* ScopeType.Builtin */) {
+                this._evaluator.addError(localize_1.Localizer.Diagnostic.typeAliasStatementBadScope(), node.name);
+            }
+        }
+        return true;
+    }
     visitTypeAnnotation(node) {
         this._evaluator.getType(node.typeAnnotation);
         return true;
@@ -1063,17 +1075,17 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // Don't explore further.
         return false;
     }
-    _getImportResult(node, filePath) {
-        const execEnv = this._importResolver.getConfigOptions().findExecEnvironment(filePath);
+    _getImportResult(node, uri) {
+        const execEnv = this._importResolver.getConfigOptions().findExecEnvironment(uri);
         const moduleNameNode = node.parent.module;
         // Handle both absolute and relative imports.
         const moduleName = moduleNameNode.leadingDots === 0
-            ? this._importResolver.getModuleNameForImport(filePath, execEnv).moduleName
-            : (0, importStatementUtils_1.getRelativeModuleName)(this._importResolver.fileSystem, this._fileInfo.filePath, filePath);
+            ? this._importResolver.getModuleNameForImport(uri, execEnv).moduleName
+            : (0, importStatementUtils_1.getRelativeModuleName)(this._importResolver.fileSystem, this._fileInfo.fileUri, uri);
         if (!moduleName) {
             return undefined;
         }
-        return this._importResolver.resolveImport(this._fileInfo.filePath, execEnv, (0, importResolver_1.createImportedModuleDescriptor)(moduleName));
+        return this._importResolver.resolveImport(this._fileInfo.fileUri, execEnv, (0, importResolver_1.createImportedModuleDescriptor)(moduleName));
     }
     _addMissingModuleSourceDiagnosticIfNeeded(importResult, node) {
         if (importResult.isNativeLib ||
@@ -1691,6 +1703,31 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         });
     }
+    // Validates that overloads use @staticmethod and @classmethod consistently.
+    _validateOverloadAttributeConsistency(node, functionType) {
+        var _a, _b, _c, _d, _e, _f;
+        let staticMethodCount = 0;
+        let classMethodCount = 0;
+        functionType.overloads.forEach((overload) => {
+            if (types_1.FunctionType.isStaticMethod(overload)) {
+                staticMethodCount++;
+            }
+            if (types_1.FunctionType.isClassMethod(overload)) {
+                classMethodCount++;
+            }
+        });
+        if (staticMethodCount > 0 && staticMethodCount < functionType.overloads.length) {
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.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);
+        }
+        if (classMethodCount > 0 && classMethodCount < functionType.overloads.length) {
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.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);
+        }
+    }
+    // Validates that overloads do not overlap with inconsistent return results.
     _validateOverloadConsistency(node, functionType, prevOverloads) {
         for (let i = 0; i < prevOverloads.length; i++) {
             const prevOverload = prevOverloads[i];
@@ -2042,7 +2079,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                                         index: index + 1,
                                     }) + diag.getString(), implementationFunction.details.declaration.node.name);
                                     if (diagnostic && overload.details.declaration) {
-                                        diagnostic.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overloadSignature(), (_b = (_a = overload.details.declaration) === null || _a === void 0 ? void 0 : _a.path) !== null && _b !== void 0 ? _b : primaryDecl.path, (_d = (_c = overload.details.declaration) === null || _c === void 0 ? void 0 : _c.range) !== null && _d !== void 0 ? _d : primaryDecl.range);
+                                        diagnostic.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.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);
                                     }
                                 }
                             }
@@ -2212,7 +2249,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                 }
                 if (primaryDeclNode) {
-                    diag.addRelatedInfo(primaryDeclInfo, primaryDecl.path, primaryDecl.range);
+                    diag.addRelatedInfo(primaryDeclInfo, primaryDecl.uri, primaryDecl.range);
                 }
             }
         };
@@ -2725,6 +2762,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         return false;
     }
+    _reportDeprecatedClassProperty(node, functionTypeResult) {
+        if (!(0, types_1.isClassInstance)(functionTypeResult.decoratedType) ||
+            !types_1.ClassType.isClassProperty(functionTypeResult.decoratedType)) {
+            return;
+        }
+        this._reportDeprecatedDiagnostic(node.name, localize_1.Localizer.Diagnostic.classPropertyDeprecated());
+    }
     _reportDeprecatedUseForMemberAccess(node, info) {
         let errorMessage;
         if (info.accessType === 'property') {
@@ -2838,6 +2882,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 // the call expression and determine whether any of them
                 // are deprecated.
                 getDeprecatedMessageForOverloadedCall(this._evaluator, subtype);
+                // 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;
+                        errorMessage = getDeprecatedMessageForFunction(overloadImpl);
+                    }
+                }
             }
         });
         if (errorMessage) {
@@ -2910,18 +2963,18 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const stdlibPath = this._importResolver.getTypeshedStdLibPath(this._fileInfo.executionEnvironment);
         if (stdlibPath &&
             this._importResolver.isStdlibModule(desc, this._fileInfo.executionEnvironment) &&
-            this._sourceMapper.isUserCode(this._fileInfo.filePath)) {
+            this._sourceMapper.isUserCode(this._fileInfo.fileUri)) {
             // This means the user has a module that is overwriting the stdlib module.
             const diag = this._evaluator.addDiagnosticForTextRange(this._fileInfo, this._fileInfo.diagnosticRuleSet.reportShadowedImports, diagnosticRules_1.DiagnosticRule.reportShadowedImports, localize_1.Localizer.Diagnostic.stdlibModuleOverridden().format({
                 name: moduleName,
-                path: this._fileInfo.filePath,
+                path: this._fileInfo.fileUri.toUserVisibleString(),
             }), this._moduleNode);
             // Add a quick action that renames the file.
             if (diag) {
                 const renameAction = {
                     action: "renameShadowedFile" /* ActionKind.RenameShadowedFileAction */,
-                    oldFile: this._fileInfo.filePath,
-                    newFile: this._sourceMapper.getNextFileName(this._fileInfo.filePath),
+                    oldUri: this._fileInfo.fileUri,
+                    newUri: this._sourceMapper.getNextFileName(this._fileInfo.fileUri),
                 };
                 diag.addAction(renameAction);
             }
@@ -2959,20 +3012,20 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (stdlibPath && this._importResolver.isStdlibModule(module, this._fileInfo.executionEnvironment)) {
             // If the definition for this name is in 'user' module, it is overwriting the stdlib module.
             const definitions = definitionProvider_1.DefinitionProvider.getDefinitionsForNode(this._sourceMapper, this._evaluator, namePartNodes[namePartNodes.length - 1], namePartNodes[namePartNodes.length - 1].start, vscode_languageserver_1.CancellationToken.None);
-            const paths = definitions ? definitions.map((d) => d.path) : [];
+            const paths = definitions ? definitions.map((d) => d.uri) : [];
             paths.forEach((p) => {
                 if (!p.startsWith(stdlibPath) && !(0, sourceMapper_1.isStubFile)(p) && this._sourceMapper.isUserCode(p)) {
                     // This means the user has a module that is overwriting the stdlib module.
                     const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportShadowedImports, diagnosticRules_1.DiagnosticRule.reportShadowedImports, localize_1.Localizer.Diagnostic.stdlibModuleOverridden().format({
                         name: nameParts.join('.'),
-                        path: p,
+                        path: p.toUserVisibleString(),
                     }), node);
                     // Add a quick action that renames the file.
                     if (diag) {
                         const renameAction = {
                             action: "renameShadowedFile" /* ActionKind.RenameShadowedFileAction */,
-                            oldFile: p,
-                            newFile: this._sourceMapper.getNextFileName(p),
+                            oldUri: p,
+                            newUri: this._sourceMapper.getNextFileName(p),
                         };
                         diag.addAction(renameAction);
                     }
@@ -3281,14 +3334,21 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         });
     }
-    // If a non-protocol class explicitly inherits from a protocol class, this method
-    // verifies that any class or instance variables declared but not assigned
-    // in the protocol class are implemented in the subclass. It also checks that any
-    // empty functions declared in the protocol are implemented in the subclass.
+    // If a non-protocol class explicitly inherits from a protocol class and does
+    // not explicit derive from ABC, this method verifies that any class or instance
+    // variables declared but not assigned in the protocol class are implemented in
+    // the subclass. It also checks that any empty functions declared in the protocol
+    // are implemented in the subclass.
     _validateProtocolCompatibility(classType, errorNode) {
         if (types_1.ClassType.isProtocolClass(classType)) {
             return;
         }
+        // If a class derives from ABC, exempt it from this check. This is used for
+        // mixins that derive from a protocol but do not directly implement all
+        // of the protocol's methods.
+        if (classType.details.mro.some((mroClass) => (0, types_1.isClass)(mroClass) && types_1.ClassType.isBuiltIn(mroClass, 'ABC'))) {
+            return;
+        }
         const diagAddendum = new diagnostic_1.DiagnosticAddendum();
         const isSymbolImplemented = (name) => {
             return classType.details.mro.some((mroClass) => {
@@ -3321,7 +3381,7 @@ 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 ((0, pathUtils_1.getFileExtension)(decls[0].path).toLowerCase() !== '.pyi') {
+                        if (!decls[0].uri.hasExtension('.pyi')) {
                             if (!isSymbolImplemented(name)) {
                                 diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.missingProtocolMember().format({
                                     name,
@@ -3401,7 +3461,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     if (diagnostic) {
                         const fieldDecls = symbol.getTypedDeclarations();
                         if (fieldDecls.length > 0) {
-                            diagnostic.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.dataClassFieldLocation(), fieldDecls[0].path, fieldDecls[0].range);
+                            diagnostic.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.dataClassFieldLocation(), fieldDecls[0].uri, fieldDecls[0].range);
                         }
                     }
                 }
@@ -3563,7 +3623,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const updatedTypeParams = classType.details.typeParameters.map((typeParam) => types_1.TypeVarType.cloneAsInvariant(typeParam));
         const updatedClassType = types_1.ClassType.cloneWithNewTypeParameters(classType, updatedTypeParams);
         const objectObject = types_1.ClassType.cloneAsInstance(objectType);
-        const dummyTypeObject = types_1.ClassType.createInstantiable('__varianceDummy', '', '', '', 0, 0, undefined, undefined);
+        const dummyTypeObject = types_1.ClassType.createInstantiable('__varianceDummy', '', '', uri_1.Uri.empty(), 0, 0, undefined, undefined);
         updatedTypeParams.forEach((param, paramIndex) => {
             // Skip variadics and ParamSpecs.
             if (param.details.isVariadic || param.details.isParamSpec) {
@@ -3751,7 +3811,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         ? localize_1.Localizer.DiagnosticAddendum.newMethodLocation()
                         : localize_1.Localizer.DiagnosticAddendum.initMethodLocation()).format({
                         type: this._evaluator.printType(types_1.ClassType.cloneAsInstance(displayOnInit ? newMethodResult.classType : initMethodResult.classType)),
-                    }), secondaryDecl.path, secondaryDecl.range);
+                    }), secondaryDecl.uri, secondaryDecl.range);
                 }
             }
         }
@@ -3947,12 +4007,63 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     // If the child class overrides this symbol with its own type, make sure
                     // the override is compatible with the overridden symbol. Otherwise use the
                     // override type.
-                    if (!this._evaluator.assignType(overriddenType, childOverrideType !== null && childOverrideType !== void 0 ? childOverrideType : overrideType)) {
+                    // Verify that the override type is assignable to (same or narrower than)
+                    // the declared type of the base symbol.
+                    const primaryDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(overriddenClassAndSymbol.symbol);
+                    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.isFrozenDataClass(overriddenClassAndSymbol.classType) &&
+                        overriddenClassAndSymbol.classType.details.dataClassEntries) {
+                        const dataclassEntry = overriddenClassAndSymbol.classType.details.dataClassEntries.find((entry) => entry.name === memberName);
+                        if (dataclassEntry) {
+                            isInvariant = false;
+                        }
+                    }
+                    let overriddenTDEntry;
+                    if (overriddenClassAndSymbol.classType.details.typedDictEntries) {
+                        overriddenTDEntry = overriddenClassAndSymbol.classType.details.typedDictEntries.get(memberName);
+                        if (overriddenTDEntry === null || overriddenTDEntry === void 0 ? void 0 : overriddenTDEntry.isReadOnly) {
+                            isInvariant = false;
+                        }
+                    }
+                    let overrideTDEntry;
+                    if (overrideClassAndSymbol.classType.details.typedDictEntries) {
+                        overrideTDEntry = overrideClassAndSymbol.classType.details.typedDictEntries.get(memberName);
+                    }
+                    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(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.Localizer.Diagnostic.baseClassVariableTypeIncompatible().format({
                             classType: childClassType.details.name,
                             name: memberName,
                         }), errorNode);
                     }
+                    else if (overriddenTDEntry && overrideTDEntry) {
+                        let isRequiredCompatible;
+                        let isReadOnlyCompatible = true;
+                        // If both classes are TypedDicts and they both define this field,
+                        // make sure the attributes are compatible.
+                        if (overriddenTDEntry.isReadOnly) {
+                            isRequiredCompatible = overrideTDEntry.isRequired || !overriddenTDEntry.isRequired;
+                        }
+                        else {
+                            isReadOnlyCompatible = !overrideTDEntry.isReadOnly;
+                            isRequiredCompatible = overrideTDEntry.isRequired === overriddenTDEntry.isRequired;
+                        }
+                        if (!isRequiredCompatible) {
+                            const message = overrideTDEntry.isRequired
+                                ? localize_1.Localizer.Diagnostic.typedDictFieldRequiredRedefinition
+                                : localize_1.Localizer.Diagnostic.typedDictFieldNotRequiredRedefinition;
+                            diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, message().format({ name: memberName }), errorNode);
+                        }
+                        else if (!isReadOnlyCompatible) {
+                            diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.Localizer.Diagnostic.typedDictFieldReadOnlyRedefinition().format({
+                                name: memberName,
+                            }), errorNode);
+                        }
+                    }
                 }
             }
         }
@@ -3960,11 +4071,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.baseClassOverriddenType().format({
                 baseClass: this._evaluator.printType((0, typeUtils_1.convertToInstance)(overriddenClassAndSymbol.classType)),
                 type: this._evaluator.printType(overriddenType),
-            }), overriddenDecl.path, overriddenDecl.range);
+            }), overriddenDecl.uri, overriddenDecl.range);
             diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.baseClassOverridesType().format({
                 baseClass: this._evaluator.printType((0, typeUtils_1.convertToInstance)(overrideClassAndSymbol.classType)),
                 type: this._evaluator.printType(overrideType),
-            }), overrideDecl.path, overrideDecl.range);
+            }), overrideDecl.uri, overrideDecl.range);
         }
     }
     // Validates that any overridden methods or variables contain the same
@@ -4129,7 +4240,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             }) + diagAddendum.getString(), decl.type === 5 /* DeclarationType.Function */ ? decl.node.name : decl.node);
                             const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
                             if (diag && origDecl) {
-                                diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenMethod(), origDecl.path, origDecl.range);
+                                diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
                             }
                         }
                     }
@@ -4145,7 +4256,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             }), decl.node.name);
                             const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
                             if (diag && origDecl) {
-                                diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.finalMethod(), origDecl.path, origDecl.range);
+                                diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.finalMethod(), origDecl.uri, origDecl.range);
                             }
                         }
                     }
@@ -4166,7 +4277,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }), lastDecl.node);
                         const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
                         if (diag && origDecl) {
-                            diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenMethod(), origDecl.path, origDecl.range);
+                            diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
                         }
                     }
                 }
@@ -4212,7 +4323,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                                     }) + diagAddendum.getString(), decls[decls.length - 1].node);
                                     const origDecl = baseClassMethodType.details.declaration;
                                     if (diag && origDecl) {
-                                        diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenMethod(), origDecl.path, origDecl.range);
+                                        diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
                                     }
                                 }
                             }
@@ -4231,7 +4342,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                                             }) + diagAddendum.getString(), decl.node.name);
                                             const origDecl = baseClassMethodType.details.declaration;
                                             if (diag && origDecl) {
-                                                diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenMethod(), origDecl.path, origDecl.range);
+                                                diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
                                             }
                                         }
                                     }
@@ -4261,6 +4372,17 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             isInvariant = false;
                         }
                     }
+                    let overriddenTDEntry;
+                    if (baseClass.details.typedDictEntries) {
+                        overriddenTDEntry = baseClass.details.typedDictEntries.get(memberName);
+                        if (overriddenTDEntry === null || overriddenTDEntry === void 0 ? void 0 : overriddenTDEntry.isReadOnly) {
+                            isInvariant = false;
+                        }
+                    }
+                    let overrideTDEntry;
+                    if (childClassType.details.typedDictEntries) {
+                        overrideTDEntry = childClassType.details.typedDictEntries.get(memberName);
+                    }
                     let diagAddendum = new diagnostic_1.DiagnosticAddendum();
                     if (!this._evaluator.assignType(baseType, overrideType, diagAddendum, 
                     /* destTypeVarContext */ undefined, 
@@ -4279,7 +4401,32 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }) + diagAddendum.getString(), (_a = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _a !== void 0 ? _a : lastDecl.node);
                         const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
                         if (diag && origDecl) {
-                            diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenSymbol(), origDecl.path, origDecl.range);
+                            diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenSymbol(), origDecl.uri, origDecl.range);
+                        }
+                    }
+                    else if (overriddenTDEntry && overrideTDEntry) {
+                        // Make sure the required/not-required attribute is compatible.
+                        let isRequiredCompatible = true;
+                        if (overriddenTDEntry.isReadOnly) {
+                            // If the read-only flag is set, a not-required field can be overridden
+                            // by a required field, but not vice versa.
+                            isRequiredCompatible = overrideTDEntry.isRequired || !overriddenTDEntry.isRequired;
+                        }
+                        else {
+                            isRequiredCompatible = overrideTDEntry.isRequired === overriddenTDEntry.isRequired;
+                        }
+                        if (!isRequiredCompatible) {
+                            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);
+                        }
+                        // 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);
                         }
                     }
                     // Verify that there is not a Final mismatch.
@@ -4291,7 +4438,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             className: baseClass.details.name,
                         }), lastDecl.node);
                         if (diag) {
-                            diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenSymbol(), overrideFinalVarDecl.path, overrideFinalVarDecl.range);
+                            diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenSymbol(), overrideFinalVarDecl.uri, overrideFinalVarDecl.range);
                         }
                     }
                     // Verify that a class variable isn't overriding an instance
@@ -4321,7 +4468,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }), (_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.overriddenSymbol(), origDecl.path, origDecl.range);
+                            diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenSymbol(), origDecl.uri, origDecl.range);
                         }
                     }
                 }