From ee0213027c25b7446e58d16c9f0cc12c532e7573 Mon Sep 17 00:00:00 2001 From: Nithin <52503252+nithin42@users.noreply.github.com> Date: Wed, 19 Aug 2026 23:46:01 +0530 Subject: [PATCH 1/5] Fix reflected operator priority for subclass right operands Python calls the reflected form of a binary operator first when the right operand's type is a proper subclass of the left operand's type and overrides the reflected magic method. Pyright always tried the left operand's method first, so `int() & Flags.A` for an IntFlag subclass evaluated to int instead of Flags. --- .../src/analyzer/operations.ts | 81 ++++++++++++++++++- .../src/analyzer/typeEvaluator.ts | 13 +++ .../src/tests/samples/operator13.py | 62 ++++++++++++++ .../src/tests/typeEvaluator8.test.ts | 6 ++ 4 files changed, 161 insertions(+), 1 deletion(-) create mode 100644 packages/pyright-internal/src/tests/samples/operator13.py diff --git a/packages/pyright-internal/src/analyzer/operations.ts b/packages/pyright-internal/src/analyzer/operations.ts index 9ecc607b6c97..28c3c4acb301 100644 --- a/packages/pyright-internal/src/analyzer/operations.ts +++ b/packages/pyright-internal/src/analyzer/operations.ts @@ -28,7 +28,9 @@ import { evaluateStaticBoolExpression } from './staticExpressions'; import { EvalFlags, MagicMethodDeprecationInfo, TypeEvaluator, TypeResult } from './typeEvaluatorTypes'; import { InferenceContext, + MemberAccessFlags, convertToInstantiable, + derivesFromClassRecursive, getLiteralTypeClassName, getTypeCondition, getUnionSubtypeCount, @@ -38,6 +40,7 @@ import { isUnboundedTupleClass, isUnionable, lookUpClassMember, + lookUpObjectMember, makeInferenceContext, mapSubtypes, preserveUnknown, @@ -1245,6 +1248,60 @@ function validateContainmentOperation( return { type, magicMethodDeprecationInfo: deprecatedInfo }; } +// Python evaluates a binary operation by calling the left operand's magic +// method first, but there is an exception to this rule: if the right operand's +// type is a proper subclass of the left operand's type and it overrides the +// reflected magic method, the reflected method is called first. +function isReflectedOperatorPrioritized( + leftType: Type, + rightType: Type, + magicMethodName: string, + altMagicMethodName: string +): boolean { + if (!isClassInstance(leftType) || !isClassInstance(rightType)) { + return false; + } + + // The right operand's class must be a proper subclass of the left operand's class. + if (ClassType.isSameGenericClass(leftType, rightType)) { + return false; + } + + if ( + !derivesFromClassRecursive( + ClassType.cloneAsInstantiable(rightType), + ClassType.cloneAsInstantiable(leftType), + /* ignoreUnknown */ true + ) + ) { + return false; + } + + // The right operand's class must override the reflected magic method. + const rightAltMember = lookUpObjectMember(rightType, altMagicMethodName, MemberAccessFlags.SkipInstanceMembers); + if (!rightAltMember) { + return false; + } + + const leftAltMember = lookUpObjectMember(leftType, altMagicMethodName, MemberAccessFlags.SkipInstanceMembers); + if ( + leftAltMember && + isClass(leftAltMember.classType) && + isClass(rightAltMember.classType) && + ClassType.isSameGenericClass(leftAltMember.classType, rightAltMember.classType) + ) { + return false; + } + + // If the left operand's class doesn't implement the normal form of the + // operator, there's nothing to prioritize over. + if (!lookUpObjectMember(leftType, magicMethodName, MemberAccessFlags.SkipInstanceMembers)) { + return false; + } + + return true; +} + function validateArithmeticOperation( evaluator: TypeEvaluator, operator: OperatorType, @@ -1304,7 +1361,29 @@ function validateArithmeticOperation( } const magicMethodName = binaryOperatorMap[operator][0]; - let resultTypeResult = evaluator.getTypeOfMagicMethodCall( + let resultTypeResult: TypeResult | undefined; + + // If the right operand's type is a proper subclass of the left + // operand's type and overrides the reflected magic method, Python + // gives the reflected form of the operator priority. + if ( + isReflectedOperatorPrioritized( + leftSubtypeExpanded, + rightSubtypeExpanded, + magicMethodName, + binaryOperatorMap[operator][1] + ) + ) { + resultTypeResult = evaluator.getTypeOfMagicMethodCall( + convertFunctionToObject(evaluator, rightSubtypeUnexpanded), + binaryOperatorMap[operator][1], + [{ type: leftSubtypeUnexpanded, isIncomplete: leftTypeResult.isIncomplete }], + errorNode, + inferenceContext + ); + } + + resultTypeResult ??= evaluator.getTypeOfMagicMethodCall( convertFunctionToObject(evaluator, leftSubtypeUnexpanded), magicMethodName, [{ type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }], diff --git a/packages/pyright-internal/src/analyzer/typeEvaluator.ts b/packages/pyright-internal/src/analyzer/typeEvaluator.ts index 85fd116e719f..b3991d7d432b 100644 --- a/packages/pyright-internal/src/analyzer/typeEvaluator.ts +++ b/packages/pyright-internal/src/analyzer/typeEvaluator.ts @@ -6853,6 +6853,12 @@ export function createTypeEvaluator( }; } + // Determines whether all of the symbol's typed declarations are methods. + function isDeclaredAsMethod(symbol: Symbol): boolean { + const decls = symbol.getTypedDeclarations(); + return decls.length > 0 && decls.every((decl) => decl.type === DeclarationType.Function); + } + function getTypeOfClassMemberName( errorNode: ExpressionNode | undefined, classType: ClassType, @@ -6888,6 +6894,13 @@ export function createTypeEvaluator( // a symbol with an inferred type. if (!memberInfo) { memberInfo = lookUpClassMember(classType, memberName, flags); + } else if (memberInfo.skippedUndeclaredType && isDeclaredAsMethod(memberInfo.symbol)) { + // A symbol without a declared type was skipped in a class that appears + // earlier in the MRO, and the declared symbol we found is a method. + // A class-scoped assignment that aliases a method (a common idiom for + // defining reflected dunder methods) overrides the base class method, + // so use the overriding symbol instead. + memberInfo = lookUpClassMember(classType, memberName, flags) ?? memberInfo; } if (!memberInfo) { diff --git a/packages/pyright-internal/src/tests/samples/operator13.py b/packages/pyright-internal/src/tests/samples/operator13.py new file mode 100644 index 000000000000..b06d1c5e41c6 --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/operator13.py @@ -0,0 +1,62 @@ +# This sample tests that the reflected form of a binary operator is given +# priority when the right operand's type is a proper subclass of the left +# operand's type and it overrides the reflected magic method. + +from enum import IntFlag, auto +from typing import Self + + +class Flags(IntFlag): + A = auto() + B = auto() + + +reveal_type(int() & Flags.A, expected_text="Flags") +reveal_type(int() | Flags.A, expected_text="Flags") +reveal_type(int() ^ Flags.A, expected_text="Flags") + +# The left operand's own method is used when both operands have the same type. +reveal_type(int() & int(), expected_text="int") + + +class Base: + def __add__(self, other: "Base") -> "Base": ... + + def __radd__(self, other: "Base") -> "Base": ... + + +class Derived(Base): + def __radd__(self, other: Base) -> Self: + return self + + +class DerivedNoOverride(Base): ... + + +def func1(base: Base, derived: Derived, no_override: DerivedNoOverride): + # The subclass overrides __radd__, so it takes priority. + reveal_type(base + derived, expected_text="Derived") + + # The subclass doesn't override __radd__, so the normal order applies. + reveal_type(base + no_override, expected_text="Base") + + # The right operand isn't a subclass of the left operand. + reveal_type(derived + base, expected_text="Base") + + +# A class-scoped assignment that aliases a method overrides a method of the +# same name in a base class rather than adopting its declared signature. +class Base2: + def __and__(self, other: "Base2") -> "Base2": ... + + def __rand__(self, other: "Base2") -> "Base2": ... + + +class Derived2(Base2): + def __and__(self, other: "Base2") -> "Derived2": ... + + __rand__ = __and__ + + +def func2(base: Base2, derived: Derived2): + reveal_type(base & derived, expected_text="Derived2") diff --git a/packages/pyright-internal/src/tests/typeEvaluator8.test.ts b/packages/pyright-internal/src/tests/typeEvaluator8.test.ts index f38c313460e2..8851bd690de2 100644 --- a/packages/pyright-internal/src/tests/typeEvaluator8.test.ts +++ b/packages/pyright-internal/src/tests/typeEvaluator8.test.ts @@ -465,6 +465,12 @@ test('Operator12', () => { TestUtils.validateResults(analysisResults, 0); }); +test('Operator13', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['operator13.py']); + + TestUtils.validateResults(analysisResults, 0); +}); + test('Optional1', () => { const configOptions = new ConfigOptions(Uri.empty()); From 6df173e7b32f30a80d59ed128dccb32579e117c6 Mon Sep 17 00:00:00 2001 From: Rich Chiodo Date: Mon, 26 Oct 2026 14:53:07 -0700 Subject: [PATCH 2/5] Fix reflected operator dispatch edge cases Restore inherited member contracts and bound-method handling. Preserve function alias identity, handle prioritized NotImplemented fallbacks, and bound ancestry checks with the existing MRO. Add regression coverage for dispatch, aliases, and inherited attributes. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- .../src/analyzer/operations.ts | 113 +++++++-- .../src/analyzer/typeEvaluator.ts | 27 +-- .../src/tests/samples/memberAccess30.py | 106 +++++++++ .../src/tests/samples/operator13.py | 219 +++++++++++++++++- .../src/tests/typeEvaluator4.test.ts | 10 + .../src/tests/typeEvaluator8.test.ts | 6 +- 6 files changed, 446 insertions(+), 35 deletions(-) create mode 100644 packages/pyright-internal/src/tests/samples/memberAccess30.py diff --git a/packages/pyright-internal/src/analyzer/operations.ts b/packages/pyright-internal/src/analyzer/operations.ts index 28c3c4acb301..12b246eb6f63 100644 --- a/packages/pyright-internal/src/analyzer/operations.ts +++ b/packages/pyright-internal/src/analyzer/operations.ts @@ -22,7 +22,14 @@ import { } from '../parser/parseNodes'; import { OperatorType } from '../parser/tokenizerTypes'; import { getInfoReader, AnalyzerNodeInfoAccessor } from './analyzerNodeInfo'; -import { getEnclosingLambda, isWithinLoop, operatorSupportsChaining, printOperator } from './parseTreeUtils'; +import { DeclarationType } from './declaration'; +import { + getEnclosingFunction, + getEnclosingLambda, + isWithinLoop, + operatorSupportsChaining, + printOperator, +} from './parseTreeUtils'; import { getScopeForNode } from './scopeUtils'; import { evaluateStaticBoolExpression } from './staticExpressions'; import { EvalFlags, MagicMethodDeprecationInfo, TypeEvaluator, TypeResult } from './typeEvaluatorTypes'; @@ -30,7 +37,6 @@ import { InferenceContext, MemberAccessFlags, convertToInstantiable, - derivesFromClassRecursive, getLiteralTypeClassName, getTypeCondition, getUnionSubtypeCount, @@ -53,6 +59,7 @@ import { import { ClassType, NeverType, + OverloadedType, Type, TypeBase, UnknownType, @@ -60,9 +67,11 @@ import { isAnyOrUnknown, isClass, isClassInstance, + isFunction, isFunctionOrOverloaded, isInstantiableClass, isNever, + isOverloaded, isUnion, } from './types'; @@ -1253,10 +1262,10 @@ function validateContainmentOperation( // type is a proper subclass of the left operand's type and it overrides the // reflected magic method, the reflected method is called first. function isReflectedOperatorPrioritized( + evaluator: TypeEvaluator, leftType: Type, rightType: Type, - magicMethodName: string, - altMagicMethodName: string + operator: OperatorType ): boolean { if (!isClassInstance(leftType) || !isClassInstance(rightType)) { return false; @@ -1267,16 +1276,15 @@ function isReflectedOperatorPrioritized( return false; } + const leftClass = ClassType.cloneAsInstantiable(leftType); if ( - !derivesFromClassRecursive( - ClassType.cloneAsInstantiable(rightType), - ClassType.cloneAsInstantiable(leftType), - /* ignoreUnknown */ true - ) + !rightType.shared.mro.some((base) => isInstantiableClass(base) && ClassType.isSameGenericClass(base, leftClass)) ) { return false; } + const [magicMethodName, altMagicMethodName] = binaryOperatorMap[operator]; + // The right operand's class must override the reflected magic method. const rightAltMember = lookUpObjectMember(rightType, altMagicMethodName, MemberAccessFlags.SkipInstanceMembers); if (!rightAltMember) { @@ -1293,6 +1301,44 @@ function isReflectedOperatorPrioritized( return false; } + if (leftAltMember && !operatorSupportsChaining(operator)) { + const leftAltType = evaluator.getTypeOfMember(leftAltMember); + const rightAltType = evaluator.getTypeOfMember(rightAltMember); + const leftFunction = isOverloaded(leftAltType) ? OverloadedType.getOverloads(leftAltType)[0] : leftAltType; + const rightFunction = isOverloaded(rightAltType) ? OverloadedType.getOverloads(rightAltType)[0] : rightAltType; + + // Rebinding the same function does not provide a different implementation. + // Nested declarations can produce distinct functions on separate calls. + if ( + isFunction(leftFunction) && + isFunction(rightFunction) && + leftFunction.shared.declaration && + leftFunction.shared.declaration === rightFunction.shared.declaration + ) { + if (!getEnclosingFunction(leftFunction.shared.declaration.node)) { + return false; + } + + const rightDecls = rightAltMember.symbol.getDeclarations(); + if (rightDecls.length === 1 && rightDecls[0].type === DeclarationType.Variable) { + const aliasSource = rightDecls[0].inferredTypeSource; + if ( + aliasSource?.nodeType === ParseNodeType.MemberAccess && + aliasSource.d.member.d.value === altMagicMethodName + ) { + const aliasClass = evaluator.getTypeOfExpression(aliasSource.d.leftExpr).type; + if ( + isInstantiableClass(aliasClass) && + lookUpClassMember(aliasClass, altMagicMethodName, MemberAccessFlags.SkipInstanceMembers) + ?.symbol === leftAltMember.symbol + ) { + return false; + } + } + } + } + } + // If the left operand's class doesn't implement the normal form of the // operator, there's nothing to prioritize over. if (!lookUpObjectMember(leftType, magicMethodName, MemberAccessFlags.SkipInstanceMembers)) { @@ -1302,6 +1348,12 @@ function isReflectedOperatorPrioritized( return true; } +function removeNotImplemented(type: Type): Type { + return mapSubtypes(type, (subtype) => + isClassInstance(subtype) && ClassType.isBuiltIn(subtype, 'types.NotImplementedType') ? undefined : subtype + ); +} + function validateArithmeticOperation( evaluator: TypeEvaluator, operator: OperatorType, @@ -1362,17 +1414,13 @@ function validateArithmeticOperation( const magicMethodName = binaryOperatorMap[operator][0]; let resultTypeResult: TypeResult | undefined; + let decliningReflectedResult: TypeResult | undefined; // If the right operand's type is a proper subclass of the left // operand's type and overrides the reflected magic method, Python // gives the reflected form of the operator priority. if ( - isReflectedOperatorPrioritized( - leftSubtypeExpanded, - rightSubtypeExpanded, - magicMethodName, - binaryOperatorMap[operator][1] - ) + isReflectedOperatorPrioritized(evaluator, leftSubtypeExpanded, rightSubtypeExpanded, operator) ) { resultTypeResult = evaluator.getTypeOfMagicMethodCall( convertFunctionToObject(evaluator, rightSubtypeUnexpanded), @@ -1381,6 +1429,14 @@ function validateArithmeticOperation( errorNode, inferenceContext ); + + if (resultTypeResult && !operatorSupportsChaining(operator)) { + const resultType = removeNotImplemented(resultTypeResult.type); + if (resultType !== resultTypeResult.type) { + decliningReflectedResult = { ...resultTypeResult, type: resultType }; + resultTypeResult = undefined; + } + } } resultTypeResult ??= evaluator.getTypeOfMagicMethodCall( @@ -1413,7 +1469,32 @@ function validateArithmeticOperation( ); } - if (!resultTypeResult) { + if (decliningReflectedResult) { + if (resultTypeResult) { + const resultType = removeNotImplemented(resultTypeResult.type); + if (resultType !== resultTypeResult.type) { + resultTypeResult = isNever(resultType) + ? undefined + : { ...resultTypeResult, type: resultType }; + } + } + + if (!isNever(decliningReflectedResult.type)) { + resultTypeResult = { + ...decliningReflectedResult, + type: combineTypes([ + decliningReflectedResult.type, + resultTypeResult?.type ?? NeverType.createNever(), + ]), + isIncomplete: decliningReflectedResult.isIncomplete || resultTypeResult?.isIncomplete, + magicMethodDeprecationInfo: + decliningReflectedResult.magicMethodDeprecationInfo ?? + resultTypeResult?.magicMethodDeprecationInfo, + }; + } + } + + if (!resultTypeResult && !decliningReflectedResult) { // Try the alternate form (swapping right and left). const altMagicMethodName = binaryOperatorMap[operator][1]; resultTypeResult = evaluator.getTypeOfMagicMethodCall( diff --git a/packages/pyright-internal/src/analyzer/typeEvaluator.ts b/packages/pyright-internal/src/analyzer/typeEvaluator.ts index b3991d7d432b..2b8ca3dd44cd 100644 --- a/packages/pyright-internal/src/analyzer/typeEvaluator.ts +++ b/packages/pyright-internal/src/analyzer/typeEvaluator.ts @@ -4208,6 +4208,7 @@ export function createTypeEvaluator( const declarations = symbolWithScope.symbol.getDeclarations(); let declaredType = getDeclaredTypeOfSymbol(symbolWithScope.symbol)?.type; + let preserveAssignedMethod = false; const fileInfo = nodeInfo.getFileInfo(nameNode); // If this is a class scope and there is no type declared for this class variable, @@ -4224,12 +4225,15 @@ export function createTypeEvaluator( ); if (memberInfo?.isTypeDeclared) { declaredType = getTypeOfMember(memberInfo); - if ( - isMethodExemptFromLsp(nameValue) && + preserveAssignedMethod = memberInfo.symbol .getTypedDeclarations() .some((decl) => decl.type === DeclarationType.Function) && isFunctionOrOverloaded(typeResult.type) && + isFunctionOrOverloaded(declaredType); + if ( + isMethodExemptFromLsp(nameValue) && + preserveAssignedMethod && isFunctionOrOverloaded(declaredType) && !isFinalVariable(memberInfo.symbol) ) { @@ -4285,8 +4289,10 @@ export function createTypeEvaluator( // Replace the assigned type with the (unnarrowed) declared type. destType = declaredType; } else { - // Constrain the resulting type to match the declared type. - destType = narrowTypeBasedOnAssignment(declaredType, typeResult).type; + // Keep class method aliases' implementation identity after validating their signatures. + destType = preserveAssignedMethod + ? typeResult.type + : narrowTypeBasedOnAssignment(declaredType, typeResult).type; } } else { // If this is a member name (within a class scope) and the member name @@ -6853,12 +6859,6 @@ export function createTypeEvaluator( }; } - // Determines whether all of the symbol's typed declarations are methods. - function isDeclaredAsMethod(symbol: Symbol): boolean { - const decls = symbol.getTypedDeclarations(); - return decls.length > 0 && decls.every((decl) => decl.type === DeclarationType.Function); - } - function getTypeOfClassMemberName( errorNode: ExpressionNode | undefined, classType: ClassType, @@ -6894,13 +6894,6 @@ export function createTypeEvaluator( // a symbol with an inferred type. if (!memberInfo) { memberInfo = lookUpClassMember(classType, memberName, flags); - } else if (memberInfo.skippedUndeclaredType && isDeclaredAsMethod(memberInfo.symbol)) { - // A symbol without a declared type was skipped in a class that appears - // earlier in the MRO, and the declared symbol we found is a method. - // A class-scoped assignment that aliases a method (a common idiom for - // defining reflected dunder methods) overrides the base class method, - // so use the overriding symbol instead. - memberInfo = lookUpClassMember(classType, memberName, flags) ?? memberInfo; } if (!memberInfo) { diff --git a/packages/pyright-internal/src/tests/samples/memberAccess30.py b/packages/pyright-internal/src/tests/samples/memberAccess30.py new file mode 100644 index 000000000000..4c881bee2abc --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/memberAccess30.py @@ -0,0 +1,106 @@ +# This sample tests that inferred instance members do not replace inherited +# method and property contracts when reading or writing an attribute. + +from typing import Callable, Protocol, final + + +class IntCallback(Protocol): + def __call__(self, value: int) -> int: ... + + +class Base: + def method(self, value: int) -> int: + return value + 1 + + +class BadReplacement(Base): + def __init__(self, callback: Callable[[str], str]): + # This should generate an error because the inherited signature is incompatible. + self.method = callback + + +class GoodReplacement(Base): + def __init__(self, callback: IntCallback): + self.method = callback + + +class StoreBoundMethod(Base): + def __init__(self): + self.method = self.method + + +class StoreSavedBoundMethod(Base): + def __init__(self): + saved = self.method + self.method = saved + + +def func1(direct: StoreBoundMethod, saved: StoreSavedBoundMethod, good: GoodReplacement): + reveal_type(direct.method, expected_text="(value: int) -> int") + reveal_type(direct.method(3), expected_text="int") + reveal_type(saved.method(3), expected_text="int") + reveal_type(good.method(3), expected_text="int") + + +class ReadOnly: + @property + def value(self) -> int: + return 7 + + +class BadReadOnly(ReadOnly): + def __init__(self): + # This should generate an error because the property has no setter. + self.value = 8 + + +class Writable: + @property + def value(self) -> int: + return 7 + + @value.setter + def value(self, new_value: int) -> None: + pass + + +class BadWritable(Writable): + def __init__(self): + # This should generate an error because the setter accepts int. + self.value = "bad" + + +class GoodWritable(Writable): + def __init__(self): + self.value = 8 + + +def func2(read_only: BadReadOnly, writable: BadWritable, good: GoodWritable): + reveal_type(writable.value, expected_text="int") + reveal_type(good.value, expected_text="int") + # This should generate an error because the property has no setter. + read_only.value = 9 + # This should generate an error because the setter accepts int. + writable.value = "bad" + + +class GenericBase[T]: + def method(self, value: int) -> T: ... + + +class BadGeneric(GenericBase[str]): + def __init__(self, callback: Callable[[bytes], bytes]): + # This should generate an error because the specialized signature is incompatible. + self.method = callback + + +class FinalBase: + @final + def method(self, value: int) -> int: + return value + + +class BadFinal(FinalBase): + def __init__(self, callback: IntCallback): + # This should generate an error because the inherited method is final. + self.method = callback diff --git a/packages/pyright-internal/src/tests/samples/operator13.py b/packages/pyright-internal/src/tests/samples/operator13.py index b06d1c5e41c6..3e099bbc146b 100644 --- a/packages/pyright-internal/src/tests/samples/operator13.py +++ b/packages/pyright-internal/src/tests/samples/operator13.py @@ -3,7 +3,8 @@ # operand's type and it overrides the reflected magic method. from enum import IntFlag, auto -from typing import Self +from types import NotImplementedType +from typing import Never, Self, overload class Flags(IntFlag): @@ -60,3 +61,219 @@ def __and__(self, other: "Base2") -> "Derived2": ... def func2(base: Base2, derived: Derived2): reveal_type(base & derived, expected_text="Derived2") + + +class RebindingBase: + def __add__(self, other: object) -> int: + return 7 + + def __radd__(self, other: object) -> str: + return "reflected" + + +class SameImplementation(RebindingBase): + __radd__ = RebindingBase.__radd__ + + +class DifferentImplementation(RebindingBase): + def reflected(self, other: object) -> str: + return "different" + + __radd__ = reflected + + +class Intermediate(RebindingBase): ... + + +class IndirectSameImplementation(Intermediate): + __radd__ = Intermediate.__radd__ + + +class Mixin: ... + + +class MultipleInheritance(Mixin, DifferentImplementation): ... + + +def func3( + base: RebindingBase, + same: SameImplementation, + different: DifferentImplementation, + indirect: IndirectSameImplementation, + multiple: MultipleInheritance, +): + reveal_type(base + same, expected_text="int") + reveal_type((base + same).bit_length(), expected_text="int") + reveal_type(base + indirect, expected_text="int") + reveal_type(base + different, expected_text="str") + reveal_type(base + multiple, expected_text="str") + + value = RebindingBase() + value += same + reveal_type(value, expected_text="int") + + +class OverloadedBase: + def __add__(self, other: object) -> int: + return 7 + + @overload + def __radd__(self, other: "OverloadedBase") -> str: ... + @overload + def __radd__(self, other: int) -> str: ... + def __radd__(self, other: "OverloadedBase | int") -> str: + return "reflected" + + +class SameOverloadedImplementation(OverloadedBase): + __radd__ = OverloadedBase.__radd__ + + +def func4(base: OverloadedBase, same: SameOverloadedImplementation): + reveal_type(base + same, expected_text="int") + + +class DeclineBase: + def __add__(self, other: object) -> int: + return 7 + + +class Declines(DeclineBase): + def __radd__(self, other: object) -> NotImplementedType: + return NotImplemented + + +class SometimesDeclines(DeclineBase): + def __radd__(self, other: object) -> str | NotImplementedType: + return NotImplemented + + +class ReturnsNone(DeclineBase): + def __radd__(self, other: object) -> None: + return None + + +class Inapplicable(DeclineBase): + def __radd__(self, other: str) -> str: + return other + + +def func5( + base: DeclineBase, + declines: Declines, + sometimes: SometimesDeclines, + returns_none: ReturnsNone, + inapplicable: Inapplicable, +): + reveal_type(base + declines, expected_text="int") + reveal_type((base + declines).bit_length(), expected_text="int") + reveal_type(base + sometimes, expected_text="str | int") + reveal_type(base + returns_none, expected_text="None") + reveal_type(base + inapplicable, expected_text="int") + reveal_type(declines.__radd__(base), expected_text="NotImplementedType") + + value = DeclineBase() + value += declines + reveal_type(value, expected_text="int") + + +class Raises: + def __add__(self, other: object) -> Never: + raise RuntimeError + + +class DeclinesToRaises(Raises): + def __radd__(self, other: object) -> NotImplementedType: + return NotImplemented + + +def func6(base: Raises, declines: DeclinesToRaises): + reveal_type(base + declines, expected_text="Never") + + +class BothDecline: + def __add__(self, other: object) -> NotImplementedType: + return NotImplemented + + +class AlsoDeclines(BothDecline): + def __radd__(self, other: object) -> NotImplementedType: + return NotImplemented + + +def func7(base: BothDecline, declines: AlsoDeclines): + # This should generate an error because neither implementation supports addition. + _ = base + declines + + +class ComparisonBase: + def __lt__(self, other: object) -> int: + return 7 + + def __gt__(self, other: object) -> str: + return "reflected" + + +class ComparisonAlias(ComparisonBase): + __gt__ = ComparisonBase.__gt__ + + +def func8(base: ComparisonBase, alias: ComparisonAlias): + # Unlike arithmetic, comparisons prioritize the subclass even for the same function. + reveal_type(base < alias, expected_text="str") + + +class RaisesFirst(DeclineBase): + def __radd__(self, other: object) -> Never: + raise RuntimeError + + +def func9(base: DeclineBase, raises: RaisesFirst): + reveal_type(base + raises, expected_text="Never") + + +class SometimesDecliningBase: + def __add__(self, other: object) -> int | NotImplementedType: + return 7 + + +class AlwaysDeclines(SometimesDecliningBase): + def __radd__(self, other: object) -> NotImplementedType: + return NotImplemented + + +class SometimesAlsoDeclines(BothDecline): + def __radd__(self, other: object) -> str | NotImplementedType: + return "reflected" + + +def func10(base: SometimesDecliningBase, declines: AlwaysDeclines, both: BothDecline, sometimes: SometimesAlsoDeclines): + reveal_type(base + declines, expected_text="int") + reveal_type(both + sometimes, expected_text="str") + + +def make_reflected(): + def reflected(self: object, other: object) -> str: + return "reflected" + + return reflected + + +class FactoryBase: + def __add__(self, other: object) -> int: + return 7 + + __radd__ = make_reflected() + + +class FactoryDerived(FactoryBase): + __radd__ = make_reflected() + + +class FactoryAlias(FactoryBase): + __radd__ = FactoryBase.__radd__ + + +def func11(base: FactoryBase, derived: FactoryDerived, alias: FactoryAlias): + reveal_type(base + derived, expected_text="str") + reveal_type(base + alias, expected_text="int") diff --git a/packages/pyright-internal/src/tests/typeEvaluator4.test.ts b/packages/pyright-internal/src/tests/typeEvaluator4.test.ts index d6dfd3db4680..56ec392dc8d2 100644 --- a/packages/pyright-internal/src/tests/typeEvaluator4.test.ts +++ b/packages/pyright-internal/src/tests/typeEvaluator4.test.ts @@ -11,6 +11,7 @@ import assert from 'assert'; import { ConfigOptions } from '../common/configOptions'; +import { DiagnosticRule } from '../common/diagnosticRules'; import { pythonVersion3_10, pythonVersion3_11, @@ -299,6 +300,15 @@ test('MemberAccess29', () => { TestUtils.validateResults(analysisResults, 3); }); +test('MemberAccess30', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['memberAccess30.py']); + TestUtils.validateResults(analysisResults, 7); + assert.deepStrictEqual( + analysisResults[0].errors.map((diagnostic) => [diagnostic.range.start.line + 1, diagnostic.getRule()]), + [19, 54, 70, 82, 84, 94, 106].map((line) => [line, DiagnosticRule.reportAttributeAccessIssue]) + ); +}); + test('DataClassNamedTuple1', () => { const analysisResults = TestUtils.typeAnalyzeSampleFiles(['dataclassNamedTuple1.py']); diff --git a/packages/pyright-internal/src/tests/typeEvaluator8.test.ts b/packages/pyright-internal/src/tests/typeEvaluator8.test.ts index 8851bd690de2..3b7d85c6db63 100644 --- a/packages/pyright-internal/src/tests/typeEvaluator8.test.ts +++ b/packages/pyright-internal/src/tests/typeEvaluator8.test.ts @@ -468,7 +468,11 @@ test('Operator12', () => { test('Operator13', () => { const analysisResults = TestUtils.typeAnalyzeSampleFiles(['operator13.py']); - TestUtils.validateResults(analysisResults, 0); + TestUtils.validateResults(analysisResults, 1); + assert.deepStrictEqual( + analysisResults[0].errors.map((diagnostic) => [diagnostic.range.start.line + 1, diagnostic.getRule()]), + [[206, DiagnosticRule.reportOperatorIssue]] + ); }); test('Optional1', () => { From 7e785071f242ee39f0b2d4185e21c77e948e029a Mon Sep 17 00:00:00 2001 From: Rich Chiodo Date: Mon, 26 Oct 2026 16:23:26 -0700 Subject: [PATCH 3/5] Preserve operator alias signatures and narrowed intersections Classify these regressions as Pyright inference limitations (B). Restore validated alias parameter and generic types while resolving callable identity only for operator dispatch. Require genuine subclass evidence before prioritizing reflected methods on synthesized intersections, and handle class operands through their effective metaclasses. Add exact signature, consumer, alias-chain, intersection, and metaclass regressions without weakening existing type expectations. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- .../src/analyzer/operations.ts | 107 ++++++++++++---- .../src/analyzer/typeEvaluator.ts | 12 +- .../pyright-internal/src/analyzer/types.ts | 3 + .../src/tests/samples/memberAccess31.py | 45 +++++++ .../src/tests/samples/operator13.py | 24 ++++ .../src/tests/samples/operator14.py | 116 ++++++++++++++++++ .../src/tests/samples/operator15.py | 45 +++++++ .../src/tests/typeEvaluator4.test.ts | 9 ++ .../src/tests/typeEvaluator8.test.ts | 16 +++ 9 files changed, 345 insertions(+), 32 deletions(-) create mode 100644 packages/pyright-internal/src/tests/samples/memberAccess31.py create mode 100644 packages/pyright-internal/src/tests/samples/operator14.py create mode 100644 packages/pyright-internal/src/tests/samples/operator15.py diff --git a/packages/pyright-internal/src/analyzer/operations.ts b/packages/pyright-internal/src/analyzer/operations.ts index 12b246eb6f63..5efd8226e4d0 100644 --- a/packages/pyright-internal/src/analyzer/operations.ts +++ b/packages/pyright-internal/src/analyzer/operations.ts @@ -19,6 +19,7 @@ import { ParseNodeType, TernaryNode, UnaryOperationNode, + isExpressionNode, } from '../parser/parseNodes'; import { OperatorType } from '../parser/tokenizerTypes'; import { getInfoReader, AnalyzerNodeInfoAccessor } from './analyzerNodeInfo'; @@ -32,10 +33,12 @@ import { } from './parseTreeUtils'; import { getScopeForNode } from './scopeUtils'; import { evaluateStaticBoolExpression } from './staticExpressions'; +import { Symbol } from './symbol'; import { EvalFlags, MagicMethodDeprecationInfo, TypeEvaluator, TypeResult } from './typeEvaluatorTypes'; import { InferenceContext, MemberAccessFlags, + ClassMember, convertToInstantiable, getLiteralTypeClassName, getTypeCondition, @@ -58,6 +61,7 @@ import { } from './typeUtils'; import { ClassType, + ClassTypeFlags, NeverType, OverloadedType, Type, @@ -1267,6 +1271,16 @@ function isReflectedOperatorPrioritized( rightType: Type, operator: OperatorType ): boolean { + // Class objects dispatch through their metaclasses. + const leftMetaclass = isInstantiableClass(leftType) ? leftType.shared.effectiveMetaclass : undefined; + const rightMetaclass = isInstantiableClass(rightType) ? rightType.shared.effectiveMetaclass : undefined; + if (leftMetaclass && isInstantiableClass(leftMetaclass)) { + leftType = ClassType.cloneAsInstance(leftMetaclass); + } + if (rightMetaclass && isInstantiableClass(rightMetaclass)) { + rightType = ClassType.cloneAsInstance(rightMetaclass); + } + if (!isClassInstance(leftType) || !isClassInstance(rightType)) { return false; } @@ -1291,6 +1305,25 @@ function isReflectedOperatorPrioritized( return false; } + // An intersection's MRO is hypothetical. Require a known subclass to + // provide the reflected implementation rather than an unrelated mix-in. + if ( + rightType.shared.flags & ClassTypeFlags.IntersectionClass && + !rightType.shared.mro.some( + (base) => + isInstantiableClass(base) && + !(base.shared.flags & ClassTypeFlags.IntersectionClass) && + !ClassType.isSameGenericClass(base, leftClass) && + base.shared.mro.some( + (ancestor) => isInstantiableClass(ancestor) && ClassType.isSameGenericClass(ancestor, leftClass) + ) && + lookUpClassMember(base, altMagicMethodName, MemberAccessFlags.SkipInstanceMembers)?.symbol === + rightAltMember.symbol + ) + ) { + return false; + } + const leftAltMember = lookUpObjectMember(leftType, altMagicMethodName, MemberAccessFlags.SkipInstanceMembers); if ( leftAltMember && @@ -1302,8 +1335,10 @@ function isReflectedOperatorPrioritized( } if (leftAltMember && !operatorSupportsChaining(operator)) { - const leftAltType = evaluator.getTypeOfMember(leftAltMember); - const rightAltType = evaluator.getTypeOfMember(rightAltMember); + const leftImplementation = getOperatorImplementation(evaluator, leftAltMember); + const rightImplementation = getOperatorImplementation(evaluator, rightAltMember); + const leftAltType = leftImplementation.type; + const rightAltType = rightImplementation.type; const leftFunction = isOverloaded(leftAltType) ? OverloadedType.getOverloads(leftAltType)[0] : leftAltType; const rightFunction = isOverloaded(rightAltType) ? OverloadedType.getOverloads(rightAltType)[0] : rightAltType; @@ -1313,29 +1348,11 @@ function isReflectedOperatorPrioritized( isFunction(leftFunction) && isFunction(rightFunction) && leftFunction.shared.declaration && - leftFunction.shared.declaration === rightFunction.shared.declaration + leftFunction.shared.declaration === rightFunction.shared.declaration && + (!getEnclosingFunction(leftFunction.shared.declaration.node) || + leftImplementation.symbol === rightImplementation.symbol) ) { - if (!getEnclosingFunction(leftFunction.shared.declaration.node)) { - return false; - } - - const rightDecls = rightAltMember.symbol.getDeclarations(); - if (rightDecls.length === 1 && rightDecls[0].type === DeclarationType.Variable) { - const aliasSource = rightDecls[0].inferredTypeSource; - if ( - aliasSource?.nodeType === ParseNodeType.MemberAccess && - aliasSource.d.member.d.value === altMagicMethodName - ) { - const aliasClass = evaluator.getTypeOfExpression(aliasSource.d.leftExpr).type; - if ( - isInstantiableClass(aliasClass) && - lookUpClassMember(aliasClass, altMagicMethodName, MemberAccessFlags.SkipInstanceMembers) - ?.symbol === leftAltMember.symbol - ) { - return false; - } - } - } + return false; } } @@ -1348,6 +1365,48 @@ function isReflectedOperatorPrioritized( return true; } +function getOperatorImplementation(evaluator: TypeEvaluator, member: ClassMember): { type: Type; symbol: Symbol } { + let symbol = member.symbol; + const visited = new Set(); + + while (!visited.has(symbol)) { + visited.add(symbol); + const declarations = symbol.getDeclarations(); + if (declarations.length !== 1 || declarations[0].type !== DeclarationType.Variable) { + return { type: evaluator.getTypeOfMember({ ...member, symbol }), symbol }; + } + + const source = declarations[0].inferredTypeSource; + if (!source || !isExpressionNode(source)) { + break; + } + + // Inspect alias sources only for dispatch identity. The callable exposed + // to callers must retain its validated, narrowed signature. + const sourceType = evaluator.getTypeOfExpression(source).type; + let sourceSymbol: Symbol | undefined; + if (source.nodeType === ParseNodeType.Name) { + sourceSymbol = evaluator.lookUpSymbolRecursive(source, source.d.value, /* honorCodeFlow */ false)?.symbol; + } else if (source.nodeType === ParseNodeType.MemberAccess) { + const receiverType = evaluator.getTypeOfExpression(source.d.leftExpr).type; + if (isInstantiableClass(receiverType)) { + sourceSymbol = lookUpClassMember( + receiverType, + source.d.member.d.value, + MemberAccessFlags.SkipInstanceMembers + )?.symbol; + } + } + + if (!sourceSymbol) { + return { type: sourceType, symbol }; + } + symbol = sourceSymbol; + } + + return { type: evaluator.getTypeOfMember(member), symbol: member.symbol }; +} + function removeNotImplemented(type: Type): Type { return mapSubtypes(type, (subtype) => isClassInstance(subtype) && ClassType.isBuiltIn(subtype, 'types.NotImplementedType') ? undefined : subtype diff --git a/packages/pyright-internal/src/analyzer/typeEvaluator.ts b/packages/pyright-internal/src/analyzer/typeEvaluator.ts index 2b8ca3dd44cd..8e361b9c9497 100644 --- a/packages/pyright-internal/src/analyzer/typeEvaluator.ts +++ b/packages/pyright-internal/src/analyzer/typeEvaluator.ts @@ -4208,7 +4208,6 @@ export function createTypeEvaluator( const declarations = symbolWithScope.symbol.getDeclarations(); let declaredType = getDeclaredTypeOfSymbol(symbolWithScope.symbol)?.type; - let preserveAssignedMethod = false; const fileInfo = nodeInfo.getFileInfo(nameNode); // If this is a class scope and there is no type declared for this class variable, @@ -4225,7 +4224,7 @@ export function createTypeEvaluator( ); if (memberInfo?.isTypeDeclared) { declaredType = getTypeOfMember(memberInfo); - preserveAssignedMethod = + const isMethodAlias = memberInfo.symbol .getTypedDeclarations() .some((decl) => decl.type === DeclarationType.Function) && @@ -4233,7 +4232,7 @@ export function createTypeEvaluator( isFunctionOrOverloaded(declaredType); if ( isMethodExemptFromLsp(nameValue) && - preserveAssignedMethod && + isMethodAlias && isFunctionOrOverloaded(declaredType) && !isFinalVariable(memberInfo.symbol) ) { @@ -4289,10 +4288,7 @@ export function createTypeEvaluator( // Replace the assigned type with the (unnarrowed) declared type. destType = declaredType; } else { - // Keep class method aliases' implementation identity after validating their signatures. - destType = preserveAssignedMethod - ? typeResult.type - : narrowTypeBasedOnAssignment(declaredType, typeResult).type; + destType = narrowTypeBasedOnAssignment(declaredType, typeResult).type; } } else { // If this is a member name (within a class scope) and the member name @@ -19086,7 +19082,7 @@ export function createTypeEvaluator( ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, - ClassTypeFlags.None, + ClassTypeFlags.IntersectionClass, ParseTreeUtils.getTypeSourceId(errorNode), /* declaredMetaclass */ undefined, effectiveMetaclass, diff --git a/packages/pyright-internal/src/analyzer/types.ts b/packages/pyright-internal/src/analyzer/types.ts index 1e837c88bfff..f6bbcc3c757a 100644 --- a/packages/pyright-internal/src/analyzer/types.ts +++ b/packages/pyright-internal/src/analyzer/types.ts @@ -720,6 +720,9 @@ export const enum ClassTypeFlags { // An explicit metaclass expression could not be resolved to a class type. HasUnresolvedMetaclass = 1 << 27, + + // Synthesized by narrowing two unrelated classes with isinstance or issubclass. + IntersectionClass = 1 << 28, } export interface DataClassBehaviors { diff --git a/packages/pyright-internal/src/tests/samples/memberAccess31.py b/packages/pyright-internal/src/tests/samples/memberAccess31.py new file mode 100644 index 000000000000..c074afae02f5 --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/memberAccess31.py @@ -0,0 +1,45 @@ +# This sample tests that method aliases retain inherited callable contracts. + + +class Base: + def convert(self, value: int) -> str: + return str(value) + + +class Derived(Base): + def helper(self, value): + return str(value) + + convert = helper + + +class TypedDerived(Base): + def helper(self, value: int) -> str: + return str(value) + + convert = helper + + +class GenericBase[T]: + def copy(self, value: T) -> T: + return value + + +class GenericDerived[T](GenericBase[T]): + def helper(self, value): + return value + + copy = helper + + +def consumers(value: Derived, typed: TypedDerived, base: Base, generic: GenericDerived[str]): + reveal_type(value.convert, expected_text="(value: int) -> str") + reveal_type(value.convert(1), expected_text="str") + reveal_type(typed.convert, expected_text="(value: int) -> str") + reveal_type(generic.copy("ok"), expected_text="str") + + # These should generate errors because the inherited parameter types are retained. + value.convert("bad") + typed.convert("bad") + base.convert("bad") + generic.copy(1) diff --git a/packages/pyright-internal/src/tests/samples/operator13.py b/packages/pyright-internal/src/tests/samples/operator13.py index 3e099bbc146b..224699c4e7b5 100644 --- a/packages/pyright-internal/src/tests/samples/operator13.py +++ b/packages/pyright-internal/src/tests/samples/operator13.py @@ -277,3 +277,27 @@ class FactoryAlias(FactoryBase): def func11(base: FactoryBase, derived: FactoryDerived, alias: FactoryAlias): reveal_type(base + derived, expected_text="str") reveal_type(base + alias, expected_text="int") + + +class ChainedImplementation(RebindingBase): + __radd__ = DifferentImplementation.__radd__ + + +class ChainedSameImplementation(RebindingBase): + __radd__ = ChainedImplementation.__radd__ + + +class ChainedFactoryAlias(FactoryBase): + __radd__ = FactoryAlias.__radd__ + + +def func12( + base: RebindingBase, + chained: ChainedImplementation, + same: ChainedSameImplementation, + factory: FactoryBase, + alias: ChainedFactoryAlias, +): + reveal_type(base + chained, expected_text="str") + reveal_type(base + same, expected_text="str") + reveal_type(factory + alias, expected_text="int") diff --git a/packages/pyright-internal/src/tests/samples/operator14.py b/packages/pyright-internal/src/tests/samples/operator14.py new file mode 100644 index 000000000000..5146a1c9ddd3 --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/operator14.py @@ -0,0 +1,116 @@ +# This sample tests reflected operator priority for class-object operands +# whose metaclasses have a proper subclass relationship. + +from types import NotImplementedType + + +class Meta(type): + def __or__(cls, other: object) -> int: + return 7 + + def __ror__(cls, other: object) -> object: + return "base reflected" + + def __add__(cls, other: object) -> int: + return 7 + + +class SubMeta(Meta): + def __ror__(cls, other: object) -> str: + return "reflected" + + def __radd__(cls, other: object) -> str: + return "reflected" + + +class NoOverrideMeta(Meta): ... + + +class AliasMeta(Meta): + __ror__ = Meta.__ror__ + + +class DifferentAliasMeta(Meta): + def reflected(cls, other: object) -> str: + return "different" + + __ror__ = reflected + + +class DecliningMeta(Meta): + def __ror__(cls, other: object) -> NotImplementedType: + return NotImplemented + + +class PartlyDecliningMeta(Meta): + def __ror__(cls, other: object) -> str | NotImplementedType: + return "reflected" + + +class UnrelatedMeta(type): + def __ror__(cls, other: object) -> str: + return "unrelated" + + +class Left(metaclass=Meta): ... + + +class Right(metaclass=SubMeta): ... + + +class OtherRight(metaclass=SubMeta): ... + + +class NoOverride(metaclass=NoOverrideMeta): ... + + +class Alias(metaclass=AliasMeta): ... + + +class DifferentAlias(metaclass=DifferentAliasMeta): ... + + +class Declines(metaclass=DecliningMeta): ... + + +class PartlyDeclines(metaclass=PartlyDecliningMeta): ... + + +class Unrelated(metaclass=UnrelatedMeta): ... + + +class Plain: ... + + +def func1() -> str: + reveal_type(Left | Right, expected_text="str") + reveal_type(Left + Right, expected_text="str") + reveal_type(Right | Left, expected_text="int") + reveal_type(Left | Left, expected_text="int") + reveal_type(Right | OtherRight, expected_text="int") + reveal_type(Left | NoOverride, expected_text="int") + reveal_type(Left | Alias, expected_text="int") + reveal_type(Left | DifferentAlias, expected_text="str") + reveal_type(Left | Unrelated, expected_text="int") + reveal_type(Plain | Right, expected_text="str") + reveal_type(Right | Plain, expected_text="int") + reveal_type(int | str, expected_text="UnionType") + return (Left | Right).upper() + + +def func2(left: type[Left], right: type[Right], alternative: type[Right] | type[NoOverride]): + reveal_type(left | right, expected_text="str") + reveal_type(left | alternative, expected_text="str | int") + reveal_type(left | Declines, expected_text="int") + reveal_type(left | PartlyDeclines, expected_text="str | int") + reveal_type(Declines.__ror__(left), expected_text="NotImplementedType") + + +def invalid_reflected_result(): + # This should generate an error because the reflected operation returns str. + return (Left | Right).bit_length() + + +def invalid_same_metaclass_result(): + # This should generate an error because normal priority returns int. + return (Left | Left).upper() diff --git a/packages/pyright-internal/src/tests/samples/operator15.py b/packages/pyright-internal/src/tests/samples/operator15.py new file mode 100644 index 000000000000..e1d8de0b23dc --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/operator15.py @@ -0,0 +1,45 @@ +# This sample tests reflected operator priority for synthesized intersections. + + +def tuple_padding(padding: tuple[int, int]) -> bool: + value = padding if isinstance(padding, int) else padding[0] + reveal_type(2 * value, expected_text="int") + reveal_type(value * 2, expected_text="tuple[int, ...] | int") + return 0 <= 2 * value + + +def list_size(size: list[int], scale: int) -> int: + value = size if isinstance(size, int) else size[0] + reveal_type(scale * value, expected_text="int") + reveal_type(value * scale, expected_text="list[int] | int") + return int(scale * value / 2) + + +def union_padding(padding: int | tuple[int, int]) -> bool: + value = padding if isinstance(padding, int) else padding[0] + reveal_type(2 * value, expected_text="int") + return 0 <= 2 * value + + +class Left: + def __mul__(self, other: object) -> int: + return 7 + + +class ReflectedMixin: + def __rmul__(self, other: Left) -> str: + return "reflected" + + +class Right(ReflectedMixin, Left): ... + + +class Tag: ... + + +def genuine_subclass(left: Left, right: Right, tag: Tag): + reveal_type(left * right, expected_text="str") + if isinstance(right, Tag): + reveal_type(left * right, expected_text="str") + if isinstance(tag, Right): + reveal_type(left * tag, expected_text="str") diff --git a/packages/pyright-internal/src/tests/typeEvaluator4.test.ts b/packages/pyright-internal/src/tests/typeEvaluator4.test.ts index 56ec392dc8d2..bd153871e79e 100644 --- a/packages/pyright-internal/src/tests/typeEvaluator4.test.ts +++ b/packages/pyright-internal/src/tests/typeEvaluator4.test.ts @@ -309,6 +309,15 @@ test('MemberAccess30', () => { ); }); +test('MemberAccess31', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['memberAccess31.py']); + TestUtils.validateResults(analysisResults, 4); + assert.deepStrictEqual( + analysisResults[0].errors.map((diagnostic) => [diagnostic.range.start.line + 1, diagnostic.getRule()]), + [42, 43, 44, 45].map((line) => [line, DiagnosticRule.reportArgumentType]) + ); +}); + test('DataClassNamedTuple1', () => { const analysisResults = TestUtils.typeAnalyzeSampleFiles(['dataclassNamedTuple1.py']); diff --git a/packages/pyright-internal/src/tests/typeEvaluator8.test.ts b/packages/pyright-internal/src/tests/typeEvaluator8.test.ts index 3b7d85c6db63..b00b82f76332 100644 --- a/packages/pyright-internal/src/tests/typeEvaluator8.test.ts +++ b/packages/pyright-internal/src/tests/typeEvaluator8.test.ts @@ -475,6 +475,22 @@ test('Operator13', () => { ); }); +test('Operator14', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['operator14.py']); + + TestUtils.validateResults(analysisResults, 2); + assert.deepStrictEqual( + analysisResults[0].errors.map((diagnostic) => [diagnostic.range.start.line + 1, diagnostic.getRule()]), + [111, 116].map((line) => [line, DiagnosticRule.reportAttributeAccessIssue]) + ); +}); + +test('Operator15', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['operator15.py']); + + TestUtils.validateResults(analysisResults, 0); +}); + test('Optional1', () => { const configOptions = new ConfigOptions(Uri.empty()); From 25375df4ebeea76e4822fedd010e6dd9040a8284 Mon Sep 17 00:00:00 2001 From: Rich Chiodo Date: Tue, 27 Oct 2026 10:33:33 -0700 Subject: [PATCH 4/5] Handle NotImplemented throughout arithmetic fallback Class B / Pyright limitation: ordinary arithmetic could leak the Any-derived NotImplementedType sentinel and disable downstream assignment and return checking. Preserve subclass dispatch priority while combining successful results and following valid fallback paths, including same-runtime-class restrictions. Add precise regression coverage for chained arithmetic, partial decline, Never, None, direct calls, and metaclasses. No typeshed changes. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- .../src/analyzer/operations.ts | 88 +++++---- .../src/tests/samples/operator16.py | 179 ++++++++++++++++++ .../src/tests/typeEvaluator8.test.ts | 19 ++ 3 files changed, 253 insertions(+), 33 deletions(-) create mode 100644 packages/pyright-internal/src/tests/samples/operator16.py diff --git a/packages/pyright-internal/src/analyzer/operations.ts b/packages/pyright-internal/src/analyzer/operations.ts index 5efd8226e4d0..cee55cd15077 100644 --- a/packages/pyright-internal/src/analyzer/operations.ts +++ b/packages/pyright-internal/src/analyzer/operations.ts @@ -1261,6 +1261,12 @@ function validateContainmentOperation( return { type, magicMethodDeprecationInfo: deprecatedInfo }; } +function getOperatorType(type: Type): Type { + // Class objects dispatch through their metaclasses. + const metaclass = isInstantiableClass(type) ? type.shared.effectiveMetaclass : undefined; + return metaclass && isInstantiableClass(metaclass) ? ClassType.cloneAsInstance(metaclass) : type; +} + // Python evaluates a binary operation by calling the left operand's magic // method first, but there is an exception to this rule: if the right operand's // type is a proper subclass of the left operand's type and it overrides the @@ -1271,15 +1277,8 @@ function isReflectedOperatorPrioritized( rightType: Type, operator: OperatorType ): boolean { - // Class objects dispatch through their metaclasses. - const leftMetaclass = isInstantiableClass(leftType) ? leftType.shared.effectiveMetaclass : undefined; - const rightMetaclass = isInstantiableClass(rightType) ? rightType.shared.effectiveMetaclass : undefined; - if (leftMetaclass && isInstantiableClass(leftMetaclass)) { - leftType = ClassType.cloneAsInstance(leftMetaclass); - } - if (rightMetaclass && isInstantiableClass(rightMetaclass)) { - rightType = ClassType.cloneAsInstance(rightMetaclass); - } + leftType = getOperatorType(leftType); + rightType = getOperatorType(rightType); if (!isClassInstance(leftType) || !isClassInstance(rightType)) { return false; @@ -1425,6 +1424,7 @@ function validateArithmeticOperation( ): TypeResult { let deprecatedInfo: MagicMethodDeprecationInfo | undefined; const isIncomplete = !!leftTypeResult.isIncomplete || !!rightTypeResult.isIncomplete; + const isArithmetic = !operatorSupportsChaining(operator); const type = evaluator.mapSubtypesExpandTypeVars( leftTypeResult.type, @@ -1473,7 +1473,8 @@ function validateArithmeticOperation( const magicMethodName = binaryOperatorMap[operator][0]; let resultTypeResult: TypeResult | undefined; - let decliningReflectedResult: TypeResult | undefined; + let decliningResult: TypeResult | undefined; + let skipReflectedFallback = false; // If the right operand's type is a proper subclass of the left // operand's type and overrides the reflected magic method, Python @@ -1489,11 +1490,12 @@ function validateArithmeticOperation( inferenceContext ); - if (resultTypeResult && !operatorSupportsChaining(operator)) { + if (resultTypeResult && isArithmetic) { const resultType = removeNotImplemented(resultTypeResult.type); if (resultType !== resultTypeResult.type) { - decliningReflectedResult = { ...resultTypeResult, type: resultType }; + decliningResult = { ...resultTypeResult, type: resultType }; resultTypeResult = undefined; + skipReflectedFallback = true; } } } @@ -1528,32 +1530,30 @@ function validateArithmeticOperation( ); } - if (decliningReflectedResult) { - if (resultTypeResult) { - const resultType = removeNotImplemented(resultTypeResult.type); - if (resultType !== resultTypeResult.type) { - resultTypeResult = isNever(resultType) - ? undefined - : { ...resultTypeResult, type: resultType }; - } - } - - if (!isNever(decliningReflectedResult.type)) { - resultTypeResult = { - ...decliningReflectedResult, - type: combineTypes([ - decliningReflectedResult.type, - resultTypeResult?.type ?? NeverType.createNever(), - ]), - isIncomplete: decliningReflectedResult.isIncomplete || resultTypeResult?.isIncomplete, + if (resultTypeResult && isArithmetic) { + const resultType = removeNotImplemented(resultTypeResult.type); + if (resultType !== resultTypeResult.type) { + decliningResult = { + ...(decliningResult ?? resultTypeResult), + type: combineTypes([decliningResult?.type ?? NeverType.createNever(), resultType]), + isIncomplete: decliningResult?.isIncomplete || resultTypeResult.isIncomplete, magicMethodDeprecationInfo: - decliningReflectedResult.magicMethodDeprecationInfo ?? - resultTypeResult?.magicMethodDeprecationInfo, + decliningResult?.magicMethodDeprecationInfo ?? + resultTypeResult.magicMethodDeprecationInfo, }; + resultTypeResult = undefined; + + // Python does not retry the reflected method for operands of the same runtime class. + const leftOperatorType = getOperatorType(leftSubtypeExpanded); + const rightOperatorType = getOperatorType(rightSubtypeExpanded); + skipReflectedFallback ||= + isClassInstance(leftOperatorType) && + isClassInstance(rightOperatorType) && + ClassType.isSameGenericClass(leftOperatorType, rightOperatorType); } } - if (!resultTypeResult && !decliningReflectedResult) { + if (!resultTypeResult && !skipReflectedFallback) { // Try the alternate form (swapping right and left). const altMagicMethodName = binaryOperatorMap[operator][1]; resultTypeResult = evaluator.getTypeOfMagicMethodCall( @@ -1590,6 +1590,28 @@ function validateArithmeticOperation( inferenceContext ); } + if (resultTypeResult && isArithmetic) { + const resultType = removeNotImplemented(resultTypeResult.type); + if (resultType !== resultTypeResult.type) { + resultTypeResult = isNever(resultType) + ? undefined + : { ...resultTypeResult, type: resultType }; + } + } + } + + if (decliningResult && !isNever(decliningResult.type)) { + resultTypeResult = { + ...decliningResult, + type: combineTypes([ + decliningResult.type, + resultTypeResult?.type ?? NeverType.createNever(), + ]), + isIncomplete: decliningResult.isIncomplete || resultTypeResult?.isIncomplete, + magicMethodDeprecationInfo: + decliningResult.magicMethodDeprecationInfo ?? + resultTypeResult?.magicMethodDeprecationInfo, + }; } if (!resultTypeResult) { diff --git a/packages/pyright-internal/src/tests/samples/operator16.py b/packages/pyright-internal/src/tests/samples/operator16.py new file mode 100644 index 000000000000..98b36af16ff2 --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/operator16.py @@ -0,0 +1,179 @@ +# This sample tests NotImplemented fallback through chained arithmetic operators. + +from types import NotImplementedType +from typing import Generic, Never, TypeVar + + +class Returned: + def __add__(self, other: object) -> int | NotImplementedType: + return NotImplemented + + +class Fallback: + def __radd__(self, other: object) -> int: + return 42 + + +class Base: + def __mul__(self, other: object) -> int: + return 1 + + +class Child(Base): + def __rmul__(self, other: object) -> Returned: + return Returned() + + +def bad_return() -> str: + result = Base() * Child() + Fallback() + reveal_type(result, expected_text="int") + # This should generate an error. + return result + + +def bad_assignment(): + # This should generate an error. + value: str = Base() * Child() + Fallback() + + +def parameterized(left: Base, right: Child) -> str: + # This should generate an error. + return left * right + Fallback() + + +def reversed_operands() -> str: + # This should generate an error. + return Child() * Base() + Fallback() + + +def augmented_assignment(): + value = Returned() + value += Fallback() + reveal_type(value, expected_text="int") + + +class AlwaysDeclines: + def __add__(self, other: object) -> NotImplementedType: + return NotImplemented + + +class StringFallback: + def __radd__(self, other: object) -> str: + return "fallback" + + +class SometimesDeclines: + def __radd__(self, other: object) -> str | NotImplementedType: + return NotImplemented + + +class ReflectedDeclines: + def __radd__(self, other: object) -> NotImplementedType: + return NotImplemented + + +class ReturnsNone: + def __radd__(self, other: object) -> None: + return None + + +def fallback_results( + left: Returned, + declines: AlwaysDeclines, + right: StringFallback, + sometimes: SometimesDeclines, + both: ReflectedDeclines, + returns_none: ReturnsNone, +): + reveal_type(left + right, expected_text="int | str") + reveal_type(declines + right, expected_text="str") + reveal_type(left + sometimes, expected_text="int | str") + reveal_type(declines + sometimes, expected_text="str") + reveal_type(left + both, expected_text="int") + reveal_type(left + returns_none, expected_text="int | None") + reveal_type(left.__add__(right), expected_text="int | NotImplementedType") + reveal_type(sometimes.__radd__(left), expected_text="str | NotImplementedType") + # This should generate an error. + _ = declines + both + + +class Raises: + def __radd__(self, other: object) -> Never: + raise RuntimeError + + +def never_fallback(left: AlwaysDeclines, right: Raises): + reveal_type(left + right, expected_text="Never") + + +def partial_never_fallback(left: Returned, right: Raises): + reveal_type(left + right, expected_text="int") + + +class SameType: + def __add__(self, other: object) -> NotImplementedType: + return NotImplemented + + def __radd__(self, other: object) -> str: + return "not called" + + +class SamePartialType: + def __add__(self, other: object) -> int | NotImplementedType: + return 1 + + def __radd__(self, other: object) -> str: + return "not called" + + +def same_type(left: SameType, right: SameType, partial: SamePartialType): + # This should generate an error. + _ = left + right + reveal_type(partial + partial, expected_text="int") + + +T = TypeVar("T") + + +class GenericDeclines(Generic[T]): + def __add__(self, other: object) -> NotImplementedType: + return NotImplemented + + def __radd__(self, other: object) -> str: + return "not called" + + +def generic_same_type(left: GenericDeclines[int], right: GenericDeclines[str]): + # This should generate an error. + _ = left + right + + +class SameMeta(type): + def __add__(cls, other: object) -> NotImplementedType: + return NotImplemented + + def __radd__(cls, other: object) -> str: + return "not called" + + +class First(metaclass=SameMeta): ... + + +class Second(metaclass=SameMeta): ... + + +def same_metaclass(): + # This should generate an error. + _ = First + Second + + +class Comparison: + def __lt__(self, other: object) -> int | NotImplementedType: + return NotImplemented + + def __gt__(self, other: object) -> str | NotImplementedType: + return NotImplemented + + +def comparison_control(left: Comparison, right: Comparison): + reveal_type(left < right, expected_text="int | NotImplementedType") diff --git a/packages/pyright-internal/src/tests/typeEvaluator8.test.ts b/packages/pyright-internal/src/tests/typeEvaluator8.test.ts index b00b82f76332..668c85b17b9f 100644 --- a/packages/pyright-internal/src/tests/typeEvaluator8.test.ts +++ b/packages/pyright-internal/src/tests/typeEvaluator8.test.ts @@ -491,6 +491,25 @@ test('Operator15', () => { TestUtils.validateResults(analysisResults, 0); }); +test('Operator16', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['operator16.py']); + + TestUtils.validateResults(analysisResults, 8); + assert.deepStrictEqual( + analysisResults[0].errors + .slice() + .sort((left, right) => left.range.start.line - right.range.start.line) + .map((diagnostic) => [diagnostic.range.start.line + 1, diagnostic.getRule()]), + [ + [31, DiagnosticRule.reportReturnType], + [36, DiagnosticRule.reportAssignmentType], + [41, DiagnosticRule.reportReturnType], + [46, DiagnosticRule.reportReturnType], + ...[97, 131, 148, 167].map((line) => [line, DiagnosticRule.reportOperatorIssue]), + ] + ); +}); + test('Optional1', () => { const configOptions = new ConfigOptions(Uri.empty()); From 37b58481cfd391dd813659c1a3d4535530c2281f Mon Sep 17 00:00:00 2001 From: Rich Chiodo Date: Tue, 27 Oct 2026 15:22:18 -0700 Subject: [PATCH 5/5] Refine inherited operator returns for bound receivers Classify the xarray false positives as a Pyright inference limitation (B), not a typeshed change. Reuse bounded call-site inference for inherited unannotated methods inferred as NotImplemented, supplying the actual bound receiver and synthetic argument types. Retain explicit return contracts and reject fully Unknown refinements. Cover normal, reflected, and metaclass calls, py.typed libraries, and unsafe Self or decorated-overload shortcuts without weakening existing type expectations. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- .../src/analyzer/typeEvaluator.ts | 63 ++++++-- ...rator.inheritedNotImplemented.fourslash.ts | 44 ++++++ .../src/tests/samples/operator17.py | 143 ++++++++++++++++++ .../src/tests/samples/operator18.py | 107 +++++++++++++ .../src/tests/samples/operator19.py | 66 ++++++++ .../src/tests/typeEvaluator8.test.ts | 49 ++++++ 6 files changed, 459 insertions(+), 13 deletions(-) create mode 100644 packages/pyright-internal/src/tests/fourslash/hover.operator.inheritedNotImplemented.fourslash.ts create mode 100644 packages/pyright-internal/src/tests/samples/operator17.py create mode 100644 packages/pyright-internal/src/tests/samples/operator18.py create mode 100644 packages/pyright-internal/src/tests/samples/operator19.py diff --git a/packages/pyright-internal/src/analyzer/typeEvaluator.ts b/packages/pyright-internal/src/analyzer/typeEvaluator.ts index 8e361b9c9497..4b2fc4a5cba7 100644 --- a/packages/pyright-internal/src/analyzer/typeEvaluator.ts +++ b/packages/pyright-internal/src/analyzer/typeEvaluator.ts @@ -25526,6 +25526,22 @@ export function createTypeEvaluator( return getInferredReturnTypeResult(type).type; } + function getNotImplementedInferenceReceiver(type: FunctionType, returnType: Type): ClassType | undefined { + const receiver = type.priv.boundToType; + if ( + !type.shared.declaredReturnType && + isClassInstance(returnType) && + ClassType.isBuiltIn(returnType, 'types.NotImplementedType') && + receiver && + type.shared.methodClass && + !ClassType.isSameGenericClass(receiver, type.shared.methodClass) + ) { + return receiver; + } + + return undefined; + } + // Returns the return type of the function. If the type is explicitly provided in // a type annotation, that type is returned. If not, an attempt is made to infer // the return type. If a list of args is provided, the inference logic may take @@ -25540,22 +25556,23 @@ export function createTypeEvaluator( // from ever running (e.g. an unannotated factory whose body narrows a // parameter-derived local with `isinstance`). When a call site is available, // fall through so the argument types can refine the inferred return type. + // The same applies to inherited methods inferred as only NotImplemented. // // NOTE: This gate intentionally mirrors a subset of the downstream call-site - // refinement guard in `_getInferredReturnTypeResult` (search `isPartlyUnknown(returnType)`), + // refinement guard in `_getInferredReturnTypeResult` (search `inheritedNotImplementedReceiver`), // but tests the cached *specialized* return type here rather than the freshly-inferred // one, and omits the `!isStubDefinition`/`!isPyTypedDefinition`/`!isIncomplete` // conjuncts (not yet known at this point). Keep the two in sync if either is edited. const canRefineWithCallSite = options?.callSiteInfo !== undefined && !type.shared.declaredReturnType && - FunctionType.hasUnannotatedParams(type) && - isPartlyUnknown(specializedReturnType); + ((FunctionType.hasUnannotatedParams(type) && isPartlyUnknown(specializedReturnType)) || + getNotImplementedInferenceReceiver(type, specializedReturnType) !== undefined); if (!canRefineWithCallSite) { return { type: specializedReturnType }; } - // Refine the cached partly-unknown return type using the call site. If the + // Refine the cached inferred return type using the call site. If the // refinement comes back incomplete -- e.g. a self- or mutually-recursive // factory whose base case returns the isinstance-narrowed local -- fall back // to the already-cached specialized return type rather than propagating the @@ -25659,16 +25676,20 @@ export function createTypeEvaluator( type.shared.inferredReturnType = { type: returnType, isIncomplete, evaluationCount: evalCount + 1 }; } - // If the type is partially unknown and the function has one or more unannotated - // params, try to analyze the function with the provided argument types and - // attempt to do a better job at inference. + // An inherited wrapper may infer only NotImplemented from a base helper, + // even though the bound receiver overrides that helper. + const inheritedNotImplementedReceiver = getNotImplementedInferenceReceiver(type, returnType); + + // Refine partially unknown returns or inherited NotImplemented wrappers + // using the call site's argument types. if ( !isIncomplete && analyzeUnannotatedFunctions && - isPartlyUnknown(returnType) && - FunctionType.hasUnannotatedParams(type) && + (inheritedNotImplementedReceiver || + (isPartlyUnknown(returnType) && + FunctionType.hasUnannotatedParams(type) && + !FunctionType.isPyTypedDefinition(type))) && !FunctionType.isStubDefinition(type) && - !FunctionType.isPyTypedDefinition(type) && callSiteInfo ) { let hasDecorators = false; @@ -25686,8 +25707,12 @@ export function createTypeEvaluator( // We can't use this technique if decorators or async are used because they // would need to be applied to the inferred return type. if (!hasDecorators && !isAsync) { - const contextualReturnType = inferReturnTypeForCallSite(type, callSiteInfo); - if (contextualReturnType) { + const contextualReturnType = inferReturnTypeForCallSite( + type, + callSiteInfo, + inheritedNotImplementedReceiver + ); + if (contextualReturnType && (!inheritedNotImplementedReceiver || !isUnknown(contextualReturnType))) { returnType = contextualReturnType; if (type.shared.declaration?.node) { @@ -25702,7 +25727,11 @@ export function createTypeEvaluator( return { type: returnType, isIncomplete }; } - function inferReturnTypeForCallSite(type: FunctionType, callSiteInfo: CallSiteEvaluationInfo): Type | undefined { + function inferReturnTypeForCallSite( + type: FunctionType, + callSiteInfo: CallSiteEvaluationInfo, + inheritedReceiver?: ClassType + ): Type | undefined { const args = callSiteInfo.args; let contextualReturnType: Type | undefined; @@ -25781,6 +25810,14 @@ export function createTypeEvaluator( if (!isUnknown(paramType)) { allArgTypesAreUnknown = false; } + } else if (inheritedReceiver && arg?.argument.typeResult) { + paramType = arg.argument.typeResult.type; + if (!isUnknown(paramType)) { + allArgTypesAreUnknown = false; + } + } else if (inheritedReceiver && index === 0) { + paramType = inheritedReceiver; + allArgTypesAreUnknown = false; } else if (param.d.defaultValue) { paramType = getTypeOfExpression(param.d.defaultValue).type; if (!isUnknown(paramType)) { diff --git a/packages/pyright-internal/src/tests/fourslash/hover.operator.inheritedNotImplemented.fourslash.ts b/packages/pyright-internal/src/tests/fourslash/hover.operator.inheritedNotImplemented.fourslash.ts new file mode 100644 index 000000000000..991892775798 --- /dev/null +++ b/packages/pyright-internal/src/tests/fourslash/hover.operator.inheritedNotImplemented.fourslash.ts @@ -0,0 +1,44 @@ +/// + +// @filename: offsets/py.typed +// @library: true +//// partial + +// @filename: offsets/__init__.py +// @library: true +//// class Base: +//// def __add__(self, other: object): +//// return self.apply(other) +//// +//// def __radd__(self, other: object): +//// return self.apply(other) +//// +//// def apply(self, other: object): +//// return NotImplemented +//// +//// class Number(Base): +//// def apply(self, other: object) -> int: +//// return 42 +//// +//// class Text(Base): +//// def apply(self, other: object) -> str: +//// return "value" + +// @filename: test.py +//// from offsets import Base, Number, Text +//// +//// def results(number: Number, text: Text, base: Base): +//// [|/*number*/number_result|] = number + number +//// [|/*text*/text_result|] = text + text +//// [|/*reflected*/reflected_result|] = base + number + +helper.verifyDiagnostics({ + number: { category: 'none', message: '' }, + text: { category: 'none', message: '' }, + reflected: { category: 'none', message: '' }, +}); +helper.verifyHover('markdown', { + number: '```python\n(variable) number_result: int\n```', + text: '```python\n(variable) text_result: str\n```', + reflected: '```python\n(variable) reflected_result: int\n```', +}); diff --git a/packages/pyright-internal/src/tests/samples/operator17.py b/packages/pyright-internal/src/tests/samples/operator17.py new file mode 100644 index 000000000000..3eec9eebaad0 --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/operator17.py @@ -0,0 +1,143 @@ +# This sample tests inferred inherited operators that delegate to an overridden helper. + +from types import NotImplementedType +from typing import Never + + +class Base: + def __add__(self, other: object): + return self.apply(other) + + def __radd__(self, other: object): + return self.apply(other) + + def apply(self, other: object): + return NotImplemented + + +class Number(Base): + # This should generate an error for the base helper's inferred return type. + def apply(self, other: object) -> int: + return 42 + + +class Text(Base): + # This should generate an error for the base helper's inferred return type. + def apply(self, other: object) -> str: + return "value" + + +class ReturnsNone(Base): + # This should generate an error for the base helper's inferred return type. + def apply(self, other: object) -> None: + return None + + +class Raises(Base): + def apply(self, other: object) -> Never: + raise RuntimeError + + +class Declines(Base): + pass + + +class Fallback: + def __radd__(self, other: object) -> str: + return "fallback" + + +def operands(number: Number, text: Text, base: Base): + reveal_type(number + number, expected_text="int") + reveal_type(number + base, expected_text="int") + reveal_type(base + number, expected_text="int") + reveal_type(text + text, expected_text="str") + reveal_type(number + text, expected_text="int") + reveal_type(text + number, expected_text="str") + reveal_type(number.__add__(number), expected_text="int") + reveal_type(text.__add__(text), expected_text="str") + # This should generate an error. + (number + number).no_such_member() + + +def bad_return(number: Number) -> str: + # This should generate an error. + return number + number + + +def bad_assignment(number: Number): + # This should generate an error. + value: str = number + number + + +def none_result(value: ReturnsNone): + reveal_type(value + value, expected_text="None") + + +def never_result(value: Raises): + reveal_type(value + value, expected_text="Never") + + +def declining_results(base: Base, value: Declines, fallback: Fallback): + reveal_type(value + fallback, expected_text="str") + # This should generate an error. + _ = base + base + # This should generate an error. + _ = value + value + + +class BaseMeta(type): + def __add__(cls, other: object): + return cls.apply(other) + + def apply(cls, other: object): + return NotImplemented + + +class NumberMeta(BaseMeta): + # This should generate an error for the base helper's inferred return type. + def apply(cls, other: object) -> int: + return 42 + + +class First(metaclass=NumberMeta): ... + + +class Second(metaclass=NumberMeta): ... + + +def metaclasses(): + reveal_type(First + Second, expected_text="int") + + +def bad_metaclass_return() -> str: + # This should generate an error. + return First + Second + + +class DeclaredBase(Base): + def __add__(self, other: object) -> NotImplementedType: + return self.apply(other) + + +class InheritedDeclaredNumber(DeclaredBase): + # This should generate an error for the base helper's inferred return type. + def apply(self, other: object) -> int: + return 42 + + +def declared_return(value: InheritedDeclaredNumber): + reveal_type(value.__add__(value), expected_text="NotImplementedType") + # This should generate an error. + _ = value + value + + +class UnknownResult(Base): + # This should generate an error for the narrower parameter type. + def apply(self, other: list): + return other[0] + + +def unknown_return(value: UnknownResult) -> str: + # This should generate an error rather than accepting an Unknown result. + return value + value diff --git a/packages/pyright-internal/src/tests/samples/operator18.py b/packages/pyright-internal/src/tests/samples/operator18.py new file mode 100644 index 000000000000..7c64570a77cc --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/operator18.py @@ -0,0 +1,107 @@ +# This sample tests that a polymorphic receiver does not erase a known decline. + +from datetime import datetime +from types import NotImplementedType +from typing import Self, TypeVar, final + + +class Offset: + def __add__(self, other): + return self.apply(other) + + def __radd__(self, other): + return self.__add__(other) + + def __neg__(self) -> Self: + return self + + def __rsub__(self, other): + if isinstance(other, Offset) and type(self) is not type(other): + raise TypeError + # This should generate an error for the base helper's inferred contract. + result = -self + other + reveal_type(result, expected_text="Unknown") + return result + + def apply(self, other): + return NotImplemented + + +class Declared: + def __add__(self, other: object) -> NotImplementedType: + return NotImplemented + + def check(self): + # This should generate an error. + _ = self + self + + +@final +class FinalClass: + def __add__(self, other): + return NotImplemented + + def check(self): + # This should generate an error. + _ = self + self + + +class FinalMethod: + @final + def __add__(self, other): + return NotImplemented + + def check(self): + # This should generate an error. + _ = self + self + + +T = TypeVar("T", bound=Offset) + + +def generic(left: T, right: T): + # This should generate an error. + _ = left + right + + +def concrete(left: Offset, right: Offset): + # This should generate an error. + _ = left + right + + +class Comparison: + def __lt__(self, other): + return NotImplemented + + def check(self): + reveal_type(self < self, expected_text="NotImplementedType") + + +class Successful: + def __add__(self, other: object) -> int | NotImplementedType: + return 42 + + def check(self): + reveal_type(self + self, expected_text="int") + + def bad_return(self) -> str: + # This should generate an error. + return self + self + + +class TypedOffset: + def __add__(self, other: object): + return self.apply(other) + + def __neg__(self) -> Self: + return self + + def __rsub__(self, other: object) -> Self | datetime: + return -self + other + + def apply(self, other: object) -> Self | datetime | NotImplementedType: + return NotImplemented + + +def typed_offset(value: TypedOffset): + reveal_type(value + value, expected_text="TypedOffset | datetime") diff --git a/packages/pyright-internal/src/tests/samples/operator19.py b/packages/pyright-internal/src/tests/samples/operator19.py new file mode 100644 index 000000000000..3332cb629752 --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/operator19.py @@ -0,0 +1,66 @@ +# This sample tests reflected contracts that intentionally widen a normal overload. + +from typing import Callable, TypeVar, overload + +T1 = TypeVar("T1") +T2 = TypeVar("T2") +T3 = TypeVar("T3") + + +def replace_other( + other: T2, +) -> Callable[[Callable[[T1, T2], T3]], Callable[[T1, T2], T3]]: + def decorate(func: Callable[[T1, T2], T3]) -> Callable[[T1, T2], T3]: + def wrapper(left: T1, right: T2) -> T3: + return func(left, other) + + return wrapper + + return decorate + + +class Expr: + def __add__(self, other: "Expr") -> "Expr": + return Expr() + + def __radd__(self, other: "Expr", /) -> "Expr": + return Expr() + + +class Number(Expr): + @overload + def __add__(self, other: "Number") -> "Number": ... + @overload + def __add__(self, other: Expr) -> Expr: ... + + def __add__(self, other: Expr) -> Expr: + if isinstance(other, Number): + return Number() + return Expr() + + +class Integer(Number): + @replace_other(Expr()) + def __radd__(self, other: Expr): + return Number.__add__(self, other) + + +class ExactInteger(Number): + def __radd__(self, other: Expr) -> Number: + return Number() + + +def contracts(left: Number, right: Integer, exact: ExactInteger): + reveal_type(left.__add__(right), expected_text="Number") + reveal_type(right.__radd__(left), expected_text="Expr") + reveal_type(left + right, expected_text="Expr") + reveal_type(left + exact, expected_text="Number") + + +def wrong_return(left: Number, right: Integer) -> Number: + # This should generate an error rather than use the normal overload's return. + return left + right + + +def exact_return(left: Number, right: ExactInteger) -> Number: + return left + right diff --git a/packages/pyright-internal/src/tests/typeEvaluator8.test.ts b/packages/pyright-internal/src/tests/typeEvaluator8.test.ts index 668c85b17b9f..efcc12e7dd5a 100644 --- a/packages/pyright-internal/src/tests/typeEvaluator8.test.ts +++ b/packages/pyright-internal/src/tests/typeEvaluator8.test.ts @@ -510,6 +510,55 @@ test('Operator16', () => { ); }); +test('Operator17', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['operator17.py']); + + TestUtils.validateResults(analysisResults, 14); + assert.deepStrictEqual( + analysisResults[0].errors + .slice() + .sort((left, right) => left.range.start.line - right.range.start.line) + .map((diagnostic) => [diagnostic.range.start.line + 1, diagnostic.getRule()]), + [ + ...[20, 26, 32].map((line) => [line, DiagnosticRule.reportIncompatibleMethodOverride]), + [60, DiagnosticRule.reportAttributeAccessIssue], + [65, DiagnosticRule.reportReturnType], + [70, DiagnosticRule.reportAssignmentType], + ...[84, 86].map((line) => [line, DiagnosticRule.reportOperatorIssue]), + [99, DiagnosticRule.reportIncompatibleMethodOverride], + [115, DiagnosticRule.reportReturnType], + [125, DiagnosticRule.reportIncompatibleMethodOverride], + [132, DiagnosticRule.reportOperatorIssue], + [137, DiagnosticRule.reportIncompatibleMethodOverride], + [143, DiagnosticRule.reportOperatorIssue], + ] + ); +}); + +test('Operator18', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['operator18.py']); + + TestUtils.validateResults(analysisResults, 7); + assert.deepStrictEqual( + analysisResults[0].errors + .slice() + .sort((left, right) => left.range.start.line - right.range.start.line) + .map((diagnostic) => [diagnostic.range.start.line + 1, diagnostic.getRule()]), + [ + ...[22, 36, 46, 56, 64, 69].map((line) => [line, DiagnosticRule.reportOperatorIssue]), + [89, DiagnosticRule.reportReturnType], + ] + ); +}); + +test('Operator19', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['operator19.py']); + + TestUtils.validateResults(analysisResults, 1); + assert.strictEqual(analysisResults[0].errors[0].range.start.line + 1, 62); + assert.strictEqual(analysisResults[0].errors[0].getRule(), DiagnosticRule.reportReturnType); +}); + test('Optional1', () => { const configOptions = new ConfigOptions(Uri.empty());