@zzzen/pyright-internal 1.2.0-dev.20241201 → 1.2.0-dev.20241215

package/dist/analyzer/checker.d.ts

@@ -97,6 +97,8 @@ export declare class Checker extends ParseTreeWalker {
     private _validateSymbolTables;
     private _reportInvalidOverload;
     private _reportFinalInLoop;
+    private _reportOverwriteOfImportedFinal;
+    private _reportOverwriteOfBuiltinsFinal;
     private _reportMultipleFinalDeclarations;
     private _reportMultipleTypeAliasDeclarations;
     private _reportIncompatibleDeclarations;

package/dist/analyzer/checker.js

@@ -2058,6 +2058,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 scope.symbolTable.forEach((symbol, name) => {
                     this._conditionallyReportUnusedSymbol(name, symbol, scope.type, dependentFileInfo);
                     this._reportIncompatibleDeclarations(name, symbol);
+                    this._reportOverwriteOfImportedFinal(name, symbol);
+                    this._reportOverwriteOfBuiltinsFinal(name, symbol, scope);
                     this._reportMultipleFinalDeclarations(name, symbol, scope.type);
                     this._reportFinalInLoop(symbol);
                     this._reportMultipleTypeAliasDeclarations(name, symbol);
@@ -2189,6 +2191,53 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.finalInLoop(), decls[0].node);
         }
     }
+    // If a variable that is marked Final in one module is imported by another
+    // module, an attempt to overwrite the imported symbol should generate an
+    // error.
+    _reportOverwriteOfImportedFinal(name, symbol) {
+        if (this._evaluator.isFinalVariable(symbol)) {
+            return;
+        }
+        const decls = symbol.getDeclarations();
+        const finalImportDecl = decls.find((decl) => {
+            if (decl.type === 8 /* DeclarationType.Alias */) {
+                const resolvedDecl = this._evaluator.resolveAliasDeclaration(decl, /* resolveLocalNames */ true);
+                if (resolvedDecl && (0, declaration_1.isVariableDeclaration)(resolvedDecl) && resolvedDecl.isFinal) {
+                    return true;
+                }
+            }
+            return false;
+        });
+        if (!finalImportDecl) {
+            return;
+        }
+        decls.forEach((decl) => {
+            var _a;
+            if (decl !== finalImportDecl) {
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.finalReassigned().format({ name }), (_a = (0, declarationUtils_1.getNameNodeForDeclaration)(decl)) !== null && _a !== void 0 ? _a : decl.node);
+            }
+        });
+    }
+    // If the builtins module (or any implicitly chained module) defines a
+    // Final variable, an attempt to overwrite it should generate an error.
+    _reportOverwriteOfBuiltinsFinal(name, symbol, scope) {
+        if (scope.type !== 4 /* ScopeType.Module */ || !scope.parent) {
+            return;
+        }
+        const shadowedSymbolInfo = scope.parent.lookUpSymbolRecursive(name);
+        if (!shadowedSymbolInfo) {
+            return;
+        }
+        if (!this._evaluator.isFinalVariable(shadowedSymbolInfo.symbol)) {
+            return;
+        }
+        const decls = symbol.getDeclarations();
+        decls.forEach((decl) => {
+            var _a;
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.finalReassigned().format({ name }), (_a = (0, declarationUtils_1.getNameNodeForDeclaration)(decl)) !== null && _a !== void 0 ? _a : decl.node);
+        });
+    }
+    // If a variable is marked Final, it should receive only one assigned value.
     _reportMultipleFinalDeclarations(name, symbol, scopeType) {
         if (!this._evaluator.isFinalVariable(symbol)) {
             return;