@zzzen/pyright-internal 1.2.0-dev.20250112 → 1.2.0-dev.20250126

package/dist/analyzer/checker.js

@@ -4128,25 +4128,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const overriddenDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(overriddenClassAndSymbol.symbol);
         if ((0, types_1.isFunction)(overriddenType) || (0, types_1.isOverloaded)(overriddenType)) {
             const diagAddendum = new diagnostic_1.DiagnosticAddendum();
-            let overrideFunction;
-            if ((0, types_1.isFunction)(overrideType)) {
-                overrideFunction = overrideType;
-            }
-            else if ((0, types_1.isOverloaded)(overrideType)) {
-                // Use the last overload.
-                const impl = types_1.OverloadedType.getImplementation(overrideType);
-                // If the last overload isn't an implementation, skip the check for this symbol.
-                if (!impl || !(0, types_1.isFunction)(impl)) {
-                    return;
-                }
-                overrideFunction = impl;
-            }
-            if (overrideFunction) {
-                if (!this._evaluator.validateOverrideMethod(overriddenType, overrideFunction, 
+            if ((0, types_1.isFunction)(overrideType) || (0, types_1.isOverloaded)(overrideType)) {
+                if (!this._evaluator.validateOverrideMethod(overriddenType, overrideType, 
                 /* baseClass */ undefined, diagAddendum, 
                 /* enforceParamNameMatch */ true)) {
-                    const decl = overrideFunction.shared.declaration;
-                    if (decl && decl.type === 5 /* DeclarationType.Function */) {
+                    if (overrideDecl && overrideDecl.type === 5 /* DeclarationType.Function */) {
                         diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.baseClassMethodTypeIncompatible().format({
                             classType: childClassType.shared.name,
                             name: memberName,
@@ -4323,7 +4309,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
             const overloads = types_1.OverloadedType.getOverloads(typeOfSymbol);
             const implementation = types_1.OverloadedType.getImplementation(typeOfSymbol);
-            this._validateOverloadFinalConsistency(overloads, implementation);
+            this._validateOverloadFinalOverride(overloads, implementation);
             this._validateOverloadAbstractConsistency(overloads, implementation);
         });
     }
@@ -4359,33 +4345,31 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         });
     }
-    _validateOverloadFinalConsistency(overloads, implementation) {
-        // If there's an implementation, it will determine whether the
-        // function is @final.
-        if (implementation && (0, types_1.isFunction)(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) => {
-                    if (types_1.FunctionType.isFinal(overload) && overload.shared.declaration?.node) {
-                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadFinalInconsistencyImpl().format({
-                            name: overload.shared.name,
-                        }), (0, declarationUtils_1.getNameNodeForDeclaration)(overload.shared.declaration) ?? overload.shared.declaration.node);
-                    }
-                });
-            }
-            return;
-        }
-        if (overloads.length > 0 && !types_1.FunctionType.isFinal(overloads[0])) {
-            overloads.slice(1).forEach((overload, index) => {
+    _validateOverloadFinalOverride(overloads, implementation) {
+        // If there's an implementation, the overloads are not allowed to be marked final or override.
+        if (implementation) {
+            overloads.forEach((overload) => {
                 if (types_1.FunctionType.isFinal(overload) && overload.shared.declaration?.node) {
-                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadFinalInconsistencyNoImpl().format({
-                        name: overload.shared.name,
-                        index: index + 2,
-                    }), (0, declarationUtils_1.getNameNodeForDeclaration)(overload.shared.declaration) ?? overload.shared.declaration.node);
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadFinalImpl(), (0, declarationUtils_1.getNameNodeForDeclaration)(overload.shared.declaration) ?? overload.shared.declaration.node);
+                }
+                if (types_1.FunctionType.isOverridden(overload) && overload.shared.declaration?.node) {
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadOverrideImpl(), (0, declarationUtils_1.getNameNodeForDeclaration)(overload.shared.declaration) ?? overload.shared.declaration.node);
                 }
             });
+            return;
+        }
+        // If there's not an implementation, only the first overload can be marked final.
+        if (overloads.length === 0) {
+            return;
         }
+        overloads.slice(1).forEach((overload, index) => {
+            if (types_1.FunctionType.isFinal(overload) && overload.shared.declaration?.node) {
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadFinalNoImpl(), (0, declarationUtils_1.getNameNodeForDeclaration)(overload.shared.declaration) ?? overload.shared.declaration.node);
+            }
+            if (types_1.FunctionType.isOverridden(overload) && overload.shared.declaration?.node) {
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadOverrideNoImpl(), (0, declarationUtils_1.getNameNodeForDeclaration)(overload.shared.declaration) ?? overload.shared.declaration.node);
+            }
+        });
     }
     // For a TypedDict class that derives from another TypedDict class
     // that is closed, verify that any new keys are compatible with the
@@ -4576,6 +4560,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (impl && (0, types_1.isFunction)(impl)) {
                 overrideFunction = impl;
             }
+            // If there is no implementation present, use the first overload.
+            if (!impl) {
+                const overloads = types_1.OverloadedType.getOverloads(overrideType);
+                if (overloads.length > 0) {
+                    overrideFunction = overloads[0];
+                }
+            }
         }
         else if ((0, types_1.isClassInstance)(overrideType) && types_1.ClassType.isPropertyClass(overrideType)) {
             if (overrideType.priv.fgetInfo) {
@@ -4613,10 +4604,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         const baseClass = baseClassAndSymbol.classType;
         const childClassSelf = types_1.ClassType.cloneAsInstance((0, typeUtils_1.selfSpecializeClass)(childClassType, { useBoundTypeVars: true }));
-        const baseType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(baseClassAndSymbol.symbol), baseClass, this._evaluator.getTypeClassType(), childClassSelf);
+        let 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 (childClassType.shared.typeVarScopeId) {
             overrideType = (0, typeUtils_1.makeTypeVarsBound)(overrideType, [childClassType.shared.typeVarScopeId]);
+            baseType = (0, typeUtils_1.makeTypeVarsBound)(baseType, [childClassType.shared.typeVarScopeId]);
         }
         if ((0, types_1.isFunction)(baseType) || (0, types_1.isOverloaded)(baseType)) {
             const diagAddendum = new diagnostic_1.DiagnosticAddendum();