diff --git a/packages/pyright-internal/src/analyzer/operations.ts b/packages/pyright-internal/src/analyzer/operations.ts index 9ecc607b6c97..cee55cd15077 100644 --- a/packages/pyright-internal/src/analyzer/operations.ts +++ b/packages/pyright-internal/src/analyzer/operations.ts @@ -19,15 +19,26 @@ import { ParseNodeType, TernaryNode, UnaryOperationNode, + isExpressionNode, } 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 { Symbol } from './symbol'; import { EvalFlags, MagicMethodDeprecationInfo, TypeEvaluator, TypeResult } from './typeEvaluatorTypes'; import { InferenceContext, + MemberAccessFlags, + ClassMember, convertToInstantiable, getLiteralTypeClassName, getTypeCondition, @@ -38,6 +49,7 @@ import { isUnboundedTupleClass, isUnionable, lookUpClassMember, + lookUpObjectMember, makeInferenceContext, mapSubtypes, preserveUnknown, @@ -49,7 +61,9 @@ import { } from './typeUtils'; import { ClassType, + ClassTypeFlags, NeverType, + OverloadedType, Type, TypeBase, UnknownType, @@ -57,9 +71,11 @@ import { isAnyOrUnknown, isClass, isClassInstance, + isFunction, isFunctionOrOverloaded, isInstantiableClass, isNever, + isOverloaded, isUnion, } from './types'; @@ -1245,6 +1261,157 @@ 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 +// reflected magic method, the reflected method is called first. +function isReflectedOperatorPrioritized( + evaluator: TypeEvaluator, + leftType: Type, + rightType: Type, + operator: OperatorType +): boolean { + leftType = getOperatorType(leftType); + rightType = getOperatorType(rightType); + + 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; + } + + const leftClass = ClassType.cloneAsInstantiable(leftType); + if ( + !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) { + 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 && + isClass(leftAltMember.classType) && + isClass(rightAltMember.classType) && + ClassType.isSameGenericClass(leftAltMember.classType, rightAltMember.classType) + ) { + return false; + } + + if (leftAltMember && !operatorSupportsChaining(operator)) { + 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; + + // 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 && + (!getEnclosingFunction(leftFunction.shared.declaration.node) || + leftImplementation.symbol === rightImplementation.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)) { + return false; + } + + 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 + ); +} + function validateArithmeticOperation( evaluator: TypeEvaluator, operator: OperatorType, @@ -1257,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, @@ -1304,7 +1472,35 @@ function validateArithmeticOperation( } const magicMethodName = binaryOperatorMap[operator][0]; - let resultTypeResult = evaluator.getTypeOfMagicMethodCall( + let resultTypeResult: 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 + // gives the reflected form of the operator priority. + if ( + isReflectedOperatorPrioritized(evaluator, leftSubtypeExpanded, rightSubtypeExpanded, operator) + ) { + resultTypeResult = evaluator.getTypeOfMagicMethodCall( + convertFunctionToObject(evaluator, rightSubtypeUnexpanded), + binaryOperatorMap[operator][1], + [{ type: leftSubtypeUnexpanded, isIncomplete: leftTypeResult.isIncomplete }], + errorNode, + inferenceContext + ); + + if (resultTypeResult && isArithmetic) { + const resultType = removeNotImplemented(resultTypeResult.type); + if (resultType !== resultTypeResult.type) { + decliningResult = { ...resultTypeResult, type: resultType }; + resultTypeResult = undefined; + skipReflectedFallback = true; + } + } + } + + resultTypeResult ??= evaluator.getTypeOfMagicMethodCall( convertFunctionToObject(evaluator, leftSubtypeUnexpanded), magicMethodName, [{ type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }], @@ -1334,7 +1530,30 @@ function validateArithmeticOperation( ); } - if (!resultTypeResult) { + 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: + 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 && !skipReflectedFallback) { // Try the alternate form (swapping right and left). const altMagicMethodName = binaryOperatorMap[operator][1]; resultTypeResult = evaluator.getTypeOfMagicMethodCall( @@ -1371,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/analyzer/typeEvaluator.ts b/packages/pyright-internal/src/analyzer/typeEvaluator.ts index 85fd116e719f..4b2fc4a5cba7 100644 --- a/packages/pyright-internal/src/analyzer/typeEvaluator.ts +++ b/packages/pyright-internal/src/analyzer/typeEvaluator.ts @@ -4224,12 +4224,15 @@ export function createTypeEvaluator( ); if (memberInfo?.isTypeDeclared) { declaredType = getTypeOfMember(memberInfo); - if ( - isMethodExemptFromLsp(nameValue) && + const isMethodAlias = memberInfo.symbol .getTypedDeclarations() .some((decl) => decl.type === DeclarationType.Function) && isFunctionOrOverloaded(typeResult.type) && + isFunctionOrOverloaded(declaredType); + if ( + isMethodExemptFromLsp(nameValue) && + isMethodAlias && isFunctionOrOverloaded(declaredType) && !isFinalVariable(memberInfo.symbol) ) { @@ -4285,7 +4288,6 @@ 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; } } else { @@ -19080,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, @@ -25524,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 @@ -25538,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 @@ -25657,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; @@ -25684,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) { @@ -25700,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; @@ -25779,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/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/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/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/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 new file mode 100644 index 000000000000..224699c4e7b5 --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/operator13.py @@ -0,0 +1,303 @@ +# 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 types import NotImplementedType +from typing import Never, Self, overload + + +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") + + +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") + + +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/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/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/typeEvaluator4.test.ts b/packages/pyright-internal/src/tests/typeEvaluator4.test.ts index d6dfd3db4680..bd153871e79e 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,24 @@ 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('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 f38c313460e2..efcc12e7dd5a 100644 --- a/packages/pyright-internal/src/tests/typeEvaluator8.test.ts +++ b/packages/pyright-internal/src/tests/typeEvaluator8.test.ts @@ -465,6 +465,100 @@ test('Operator12', () => { TestUtils.validateResults(analysisResults, 0); }); +test('Operator13', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['operator13.py']); + + TestUtils.validateResults(analysisResults, 1); + assert.deepStrictEqual( + analysisResults[0].errors.map((diagnostic) => [diagnostic.range.start.line + 1, diagnostic.getRule()]), + [[206, DiagnosticRule.reportOperatorIssue]] + ); +}); + +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('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('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());