@zzzen/pyright-internal 1.2.0-dev.20260712 → 1.2.0-dev.20260719

package/dist/analyzer/checker.d.ts

@@ -145,6 +145,8 @@ export declare class Checker extends ParseTreeWalker {
     private _validateOverrideDecoratorPresent;
     private _isMethodExemptFromLsp;
     private _validateOverrideDecoratorNotPresent;
+    private _getCallableVariableOverrideComparison;
+    private _markFunctionStatic;
     private _validateBaseClassOverride;
     private _isFinalFunction;
     private _validatePropertyOverride;

package/dist/analyzer/checker.js

@@ -4121,7 +4121,17 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if ((0, types_1.isFunctionOrOverloaded)(overriddenType)) {
             const diagAddendum = new diagnostic_1.DiagnosticAddendum();
             if ((0, types_1.isFunctionOrOverloaded)(overrideType)) {
-                if (!this._evaluator.validateOverrideMethod(overriddenType, overrideType, 
+                // If one base defines the member as a plain callable variable and a
+                // sibling base overrides it with a real method, bind the method's "self"
+                // so the two are compared as plain callables (mirrors the single-base
+                // override handling in `_validateBaseClassOverride`). This is
+                // load-bearing for parametered callables (e.g. `Callable[[int], None]`
+                // vs `def cb(self, value: int)`): without binding, the method's extra
+                // "self" causes a spurious arity mismatch. See the `DiamondParam*`
+                // samples in methodOverride7.py.
+                const childClassSelf = types_1.ClassType.cloneAsInstance((0, typeUtils_1.selfSpecializeClass)(childClassType, { useBoundTypeVars: true }));
+                const { baseType: overriddenTypeForComparison, overrideType: overrideTypeForComparison } = this._getCallableVariableOverrideComparison(overriddenClassAndSymbol.symbol, overrideClassAndSymbol.symbol, overriddenType, overrideType, childClassType, childClassSelf);
+                if (!this._evaluator.validateOverrideMethod(overriddenTypeForComparison, overrideTypeForComparison, 
                 /* baseClass */ undefined, diagAddendum, 
                 /* enforceParamNameMatch */ true)) {
                     if (overrideDecl && overrideDecl.type === 5 /* DeclarationType.Function */) {
@@ -4242,6 +4252,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // Is the method present on the base class but missing in the subclass?
             if (baseClassPropMethod) {
                 const baseClassMethodType = (0, typeUtils_1.partiallySpecializeType)(baseClassPropMethod, overriddenClassType, this._evaluator.getTypeClassType());
+                // Overloaded accessors (e.g. overloaded property setters) are
+                // represented as an OverloadedType rather than a FunctionType.
+                // Override-compatibility checking for overloaded accessors is not
+                // yet performed; only single-function accessors are validated here.
                 if ((0, types_1.isFunction)(baseClassMethodType)) {
                     if (!subclassPropMethod) {
                         // The method is missing.
@@ -4513,7 +4527,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
         else if ((0, types_1.isClassInstance)(overrideType) && types_1.ClassType.isPropertyClass(overrideType)) {
-            if (overrideType.priv.fgetInfo) {
+            if (overrideType.priv.fgetInfo && (0, types_1.isFunction)(overrideType.priv.fgetInfo.methodType)) {
                 overrideFunction = overrideType.priv.fgetInfo.methodType;
             }
         }
@@ -4566,7 +4580,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
         else if ((0, types_1.isClassInstance)(overrideType) && types_1.ClassType.isPropertyClass(overrideType)) {
-            if (overrideType.priv.fgetInfo) {
+            if (overrideType.priv.fgetInfo && (0, types_1.isFunction)(overrideType.priv.fgetInfo.methodType)) {
                 overrideFunction = overrideType.priv.fgetInfo.methodType;
             }
         }
@@ -4581,6 +4595,65 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         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);
     }
+    // If a base class member is a plain callable variable (e.g. `x: Callable[..., None]`)
+    // and the override is a real method, accessing the override on an instance binds its
+    // "self" parameter, leaving a signature that should be compared against the base
+    // callable. This helper detects that asymmetry and returns adjusted types: the bound
+    // override and the base callable, both marked static so the override comparison does
+    // not skip the first parameter as an unbound "self". All other cases are returned
+    // unchanged. This matches the behavior of other type checkers, which allow overriding
+    // a callable attribute with a method.
+    //
+    // Note: this validates only the read direction (the bound override is compatible with
+    // the base callable). A method is effectively read-only, so this intentionally does not
+    // attempt to preserve assignability of the mutable callable attribute; that asymmetry
+    // matches other type checkers and does not trigger `reportIncompatibleVariableOverride`
+    // because the override is a function, not a variable.
+    _getCallableVariableOverrideComparison(baseSymbol, overrideSymbol, baseType, overrideType, childClassType, childClassSelf) {
+        const baseDecls = baseSymbol.getDeclarations();
+        const baseIsCallableVariable = baseDecls.length > 0 && baseDecls.every((decl) => decl.type === 1 /* DeclarationType.Variable */);
+        const overrideIsMethod = overrideSymbol
+            .getDeclarations()
+            .some((decl) => decl.type === 5 /* DeclarationType.Function */);
+        if (!baseIsCallableVariable || !overrideIsMethod) {
+            return { baseType, overrideType };
+        }
+        const boundOverrideType = this._evaluator.bindFunctionToClassOrObject(childClassSelf, overrideType, childClassType);
+        if (!boundOverrideType) {
+            return { baseType, overrideType };
+        }
+        // Mark both the base callable and the bound override as static so the
+        // override comparison does not skip the first parameter as an unbound
+        // "self" (see the `i === 0` self/cls skip in typeEvaluator's
+        // `validateOverrideMethodInternal`). Without this, the bound override
+        // keeps its instance-method flag and its first real parameter would be
+        // silently dropped during the comparison.
+        const staticBaseType = (0, types_1.isFunction)(baseType) ? this._markFunctionStatic(baseType) : baseType;
+        if ((0, types_1.isFunction)(boundOverrideType)) {
+            return {
+                baseType: staticBaseType,
+                overrideType: this._markFunctionStatic(boundOverrideType),
+            };
+        }
+        if ((0, types_1.isOverloaded)(boundOverrideType)) {
+            // An overloaded method binds to an overloaded callable. Apply the
+            // same static normalization to every overload (and the
+            // implementation, if present) so an incompatible first parameter in
+            // an overloaded override is still caught rather than skipped as
+            // "self".
+            const staticOverloads = types_1.OverloadedType.getOverloads(boundOverrideType).map((overload) => this._markFunctionStatic(overload));
+            const impl = types_1.OverloadedType.getImplementation(boundOverrideType);
+            const staticImpl = impl && (0, types_1.isFunction)(impl) ? this._markFunctionStatic(impl) : impl;
+            return {
+                baseType: staticBaseType,
+                overrideType: types_1.OverloadedType.create(staticOverloads, staticImpl),
+            };
+        }
+        return { baseType, overrideType: boundOverrideType };
+    }
+    _markFunctionStatic(functionType) {
+        return types_1.FunctionType.cloneWithNewFlags(functionType, functionType.shared.flags | 4 /* FunctionTypeFlags.StaticMethod */);
+    }
     _validateBaseClassOverride(baseClassAndSymbol, overrideSymbol, overrideType, childClassType, memberName) {
         if (!(0, types_1.isInstantiableClass)(baseClassAndSymbol.classType)) {
             return;
@@ -4643,7 +4716,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 // are misnamed in typeshed stubs, so this would result in many
                 // false positives.
                 const enforceParamNameMatch = !SymbolNameUtils.isDunderName(memberName);
-                if (this._evaluator.validateOverrideMethod(baseType, overrideType, childClassType, diagAddendum, enforceParamNameMatch)) {
+                // If the base class member is a plain callable variable
+                // (e.g. `x: Callable[..., None]`) rather than an actual method,
+                // bind the override method's "self" so the two are compared as
+                // plain callables. The declaration scans needed to detect this
+                // are computed inside this helper, so the common method-vs-method
+                // path and the exempt/private/TypedDict early-returns above pay
+                // nothing extra.
+                const { baseType: baseTypeForComparison, overrideType: overrideTypeForComparison } = this._getCallableVariableOverrideComparison(baseClassAndSymbol.symbol, overrideSymbol, baseType, overrideType, childClassType, childClassSelf);
+                if (this._evaluator.validateOverrideMethod(baseTypeForComparison, overrideTypeForComparison, childClassType, diagAddendum, enforceParamNameMatch)) {
                     return;
                 }
                 const decl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(overrideSymbol);
@@ -4867,6 +4948,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // Is the method present on the base class but missing in the subclass?
             if (baseClassPropMethod) {
                 const baseClassMethodType = (0, typeUtils_1.partiallySpecializeType)(baseClassPropMethod, baseClassType, this._evaluator.getTypeClassType());
+                // Overloaded accessors (e.g. overloaded property setters) are
+                // represented as an OverloadedType rather than a FunctionType.
+                // Override-compatibility checking for overloaded accessors is not
+                // yet performed; skip them rather than misreporting.
                 if (!(0, types_1.isFunction)(baseClassMethodType)) {
                     return;
                 }