-- Test cases for function overloading

[case testOverloadNotImportedNoCrash]

@overload

def f(a): pass

@overload

def f(a): pass

def f(a): pass

f(0)

@overload # E: Name "overload" is not defined

def g(a:int): pass

def g(a): pass # E: Name "g" already defined on line 9

g(0)

@something # E: Name "something" is not defined

def r(a:int): pass

def r(a): pass # E: Name "r" already defined on line 14

r(0)

[out]

main:2: error: Name "overload" is not defined

main:4: error: Name "f" already defined on line 2

main:4: error: Name "overload" is not defined

main:6: error: Name "f" already defined on line 2

[case testTypeCheckOverloadWithImplementation]

from typing import overload, Any

class A: pass

class B: pass

@overload

def f(x: 'A') -> 'B': ...

@overload

def f(x: 'B') -> 'A': ...

def f(x: Any) -> Any:

pass

reveal_type(f(A())) # N: Revealed type is "__main__.B"

reveal_type(f(B())) # N: Revealed type is "__main__.A"

[builtins fixtures/isinstance.pyi]

[case testTypingExtensionsOverload]

from typing import Any

from typing_extensions import overload

class A: pass

class B: pass

@overload

def f(x: 'A') -> 'B': ...

@overload

def f(x: 'B') -> 'A': ...

def f(x: Any) -> Any:

pass

reveal_type(f(A())) # N: Revealed type is "__main__.B"

reveal_type(f(B())) # N: Revealed type is "__main__.A"

[builtins fixtures/isinstance.pyi]

[case testOverloadNeedsImplementation]

from typing import overload, Any

class A: pass

class B: pass

@overload # E: An overloaded function outside a stub file must have an implementation

def f(x: 'A') -> 'B': ...

@overload

def f(x: 'B') -> 'A': ...

reveal_type(f(A())) # N: Revealed type is "__main__.B"

reveal_type(f(B())) # N: Revealed type is "__main__.A"

[builtins fixtures/isinstance.pyi]

[case testSingleOverloadNoImplementation]

from typing import overload, Any

@overload # E: Single overload definition, multiple required

def f(x: 'A') -> 'B': ...

class A: pass

class B: pass

[builtins fixtures/isinstance.pyi]

[case testOverloadByAnyOtherName]

from typing import overload as rose

from typing import Any

class A: pass

class B: pass

@rose

def f(x: 'A') -> 'B': ...

@rose

def f(x: 'B') -> 'A': ...

def f(x: Any) -> Any:

pass

reveal_type(f(A())) # N: Revealed type is "__main__.B"

reveal_type(f(B())) # N: Revealed type is "__main__.A"

[builtins fixtures/isinstance.pyi]

[case testTypeCheckOverloadWithDecoratedImplementation]

from typing import overload, Any

class A: pass

class B: pass

def deco(fun): ...

@overload

def f(x: 'A') -> 'B': ...

@overload

def f(x: 'B') -> 'A': ...

@deco

def f(x: Any) -> Any:

pass

reveal_type(f(A())) # N: Revealed type is "__main__.B"

reveal_type(f(B())) # N: Revealed type is "__main__.A"

[builtins fixtures/isinstance.pyi]

[case testOverloadDecoratedImplementationNotLast]

from typing import overload, Any

def deco(fun): ...

@overload

def f(x: 'A') -> 'B': ...

@deco # E: The implementation for an overloaded function must come last

def f(x: Any) -> Any:

pass

@overload

def f(x: 'B') -> 'A': ...

class A: pass

class B: pass

[builtins fixtures/isinstance.pyi]

[case testOverloadImplementationNotLast]

from typing import overload, Any

@overload

def f(x: 'A') -> 'B': ...

def f(x: Any) -> Any: # E: The implementation for an overloaded function must come last

pass

@overload

def f(x: 'B') -> 'A': ...

class A: pass

class B: pass

[builtins fixtures/isinstance.pyi]

[case testDecoratedRedefinitionIsNotOverload]

from typing import overload, Any

def deco(fun): ...

@deco

def f(x: 'A') -> 'B': ...

@deco # E: Name "f" already defined on line 5

def f(x: 'B') -> 'A': ...

@deco # E: Name "f" already defined on line 5

def f(x: Any) -> Any: ...

class A: pass

class B: pass

[builtins fixtures/isinstance.pyi]

[case testTypeCheckOverloadWithImplementationError]

from typing import overload, Any

class A: pass

class B: pass

@overload

def f(x: 'A') -> 'B': ...

@overload

def f(x: 'B') -> 'A': ...

def f(x: Any) -> Any:

foo = 1

if int():

foo = "bar" # E: Incompatible types in assignment (expression has type "str", variable has type "int")

@overload

def g(x: 'A') -> 'B': ...

@overload

def g(x: 'B') -> 'A': ...

def g(x):

foo = 1

if int():

foo = "bar"

reveal_type(f(A())) # N: Revealed type is "__main__.B"

reveal_type(f(B())) # N: Revealed type is "__main__.A"

[builtins fixtures/isinstance.pyi]

[case testTypeCheckOverloadWithUntypedImplAndMultipleVariants]

from typing import overload

@overload

def f(x: int) -> str: ...

@overload

def f(x: str) -> int: ... # E: Overloaded function signatures 2 and 3 overlap with incompatible return types

@overload

def f(x: object) -> str: ...

def f(x): ...

[case testTypeCheckOverloadWithImplTooSpecificArg]

from typing import overload, Any

class A: pass

class B: pass

a = A()

@overload

def f(x: 'A') -> 'B': ...

@overload

def f(x: 'B') -> 'A': ...

def f(x: 'A') -> Any: # E: Overloaded function implementation does not accept all possible parameters of signature 2

pass

reveal_type(f(A())) # N: Revealed type is "__main__.B"

reveal_type(f(B())) # N: Revealed type is "__main__.A"

[builtins fixtures/isinstance.pyi]

[case testTypeCheckOverloadImplOverlapVarArgsAndKwargs]

from __future__ import annotations

from typing import overload

@overload

def foo(x: int) -> None: ...

@overload

def foo(a: str, /) -> None: ...

def foo(*args: int | str, **kw: int) -> None:

pass

[builtins fixtures/tuple.pyi]

[case testTypeCheckOverloadImplOverlapVarArgsAndKwargsUnion]

from __future__ import annotations

from typing import overload

class Foo: ...

@overload

def foo(x: int) -> None: ...

@overload

def foo(*, x: Foo) -> None: ...

@overload

def foo(a: str, /) -> None: ...

def foo(*args: int | str, **kw: int | Foo) -> None:

pass

[builtins fixtures/tuple.pyi]

[case testTypeCheckOverloadImplOverlapVarArgsAndKwargsNever]

from __future__ import annotations

from typing import overload

@overload # E: Single overload definition, multiple required

def foo(x: int) -> None: ...

def foo(*args: int, **kw: str) -> None: # E: Overloaded function implementation does not accept all possible parameters of signature 1

pass

[builtins fixtures/tuple.pyi]

[case testTypeCheckOverloadWithImplTooSpecificRetType]

from typing import overload, Any

class A: pass

class B: pass

a = A()

@overload

def f(x: 'A') -> 'B': ...

@overload

def f(x: 'B') -> 'A': ...

def f(x: Any) -> 'B': # E: Overloaded function implementation cannot produce return type of signature 2

return B()

reveal_type(f(A())) # N: Revealed type is "__main__.B"

reveal_type(f(B())) # N: Revealed type is "__main__.A"

[builtins fixtures/isinstance.pyi]

[case testTypeCheckOverloadWithImplTypeVar]

from typing import overload, Any, TypeVar

T = TypeVar('T')

class A: pass

class B: pass

a = A()

@overload

def f(x: 'A') -> 'A': ...

@overload

def f(x: 'B') -> 'B': ...

def f(x: T) -> T:

...

reveal_type(f(A())) # N: Revealed type is "__main__.A"

reveal_type(f(B())) # N: Revealed type is "__main__.B"

[builtins fixtures/isinstance.pyi]

[case testTypeCheckOverloadWithImplTypeVarProblems]

from typing import overload, Any, TypeVar, Union

T = TypeVar('T', bound='A')

class A: pass

class B: pass

a = A()

@overload

def f(x: 'A') -> 'A': ...

@overload

def f(x: 'B') -> 'B': ...

def f(x: Union[T, B]) -> T: # E: Overloaded function implementation cannot satisfy signature 2 due to inconsistencies in how they use type variables

...

reveal_type(f(A())) # N: Revealed type is "__main__.A"

reveal_type(f(B())) # N: Revealed type is "__main__.B"

[builtins fixtures/isinstance.pyi]

[case testTypeCheckOverloadImplementationTypeVarWithValueRestriction]

from typing import overload, TypeVar, Union

class A: pass

class B: pass

class C: pass

T = TypeVar('T', A, B)

@overload

def foo(x: T) -> T: ...

@overload

def foo(x: C) -> int: ...

def foo(x: Union[A, B, C]) -> Union[A, B, int]:

if isinstance(x, C):

return 3

else:

return x

@overload

def bar(x: T) -> T: ...

@overload

def bar(x: C) -> int: ...

def bar(x: Union[T, C]) -> Union[T, int]:

if isinstance(x, C):

return 3

else:

return x

[builtins fixtures/isinstancelist.pyi]

[case testTypeCheckOverloadImplementationTypeVarDifferingUsage1]

from typing import overload, Union, List, TypeVar, Generic

T = TypeVar('T')

@overload

def foo(t: List[T]) -> T: ...

@overload

def foo(t: T) -> T: ...

def foo(t: Union[List[T], T]) -> T:

if isinstance(t, list):

return t[0]

else:

return t

class Wrapper(Generic[T]):

@overload

def foo(self, t: List[T]) -> T: ...

@overload

def foo(self, t: T) -> T: ...

def foo(self, t: Union[List[T], T]) -> T:

if isinstance(t, list):

return t[0]

else:

return t

[builtins fixtures/isinstancelist.pyi]

[case testTypeCheckOverloadImplementationTypeVarDifferingUsage2]

from typing import overload, Union, List, TypeVar, Generic

T = TypeVar('T')

# Note: this is unsafe when T = object

@overload

def foo(t: List[T], s: T) -> int: ... # E: Overloaded function signatures 1 and 2 overlap with incompatible return types

@overload

def foo(t: T, s: T) -> str: ...

def foo(t, s): pass

class Wrapper(Generic[T]):

@overload

def foo(self, t: List[T], s: T) -> int: ... # E: Overloaded function signatures 1 and 2 overlap with incompatible return types \

# N: Flipping the order of overloads will fix this error

@overload

def foo(self, t: T, s: T) -> str: ...

def foo(self, t, s): pass

class Dummy(Generic[T]): pass

# Same root issue: why does the additional constraint bound T <: T

# cause the constraint solver to not infer T = object like it did in the

# first example?

@overload

def bar(d: Dummy[T], t: List[T], s: T) -> int: ... # E: Overloaded function signatures 1 and 2 overlap with incompatible return types \

# N: Flipping the order of overloads will fix this error

@overload

def bar(d: Dummy[T], t: T, s: T) -> str: ...

def bar(d: Dummy[T], t, s): pass

[builtins fixtures/isinstancelist.pyi]

[case testTypeCheckOverloadedFunctionBody]

from foo import *

[file foo.pyi]

from typing import overload

@overload

def f(x: 'A'):

if int():

x = B() # E: Incompatible types in assignment (expression has type "B", variable has type "A")

x = A()

@overload

def f(x: 'B'):

if int():

x = A() # E: Incompatible types in assignment (expression has type "A", variable has type "B")

x = B()

class A: pass

class B: pass

[out]

[case testTypeCheckOverloadedMethodBody]

from foo import *

[file foo.pyi]

from typing import overload

class A:

@overload

def f(self, x: 'A'):

if int():

x = B() # E: Incompatible types in assignment (expression has type "B", variable has type "A")

x = A()

@overload

def f(self, x: 'B'):

if int():

x = A() # E: Incompatible types in assignment (expression has type "A", variable has type "B")

x = B()

class B: pass

[out]

[case testCallToOverloadedFunction]

from foo import *

[file foo.pyi]

from typing import overload

f(C()) # E: No overload variant of "f" matches argument type "C" \

# N: Possible overload variants: \

# N: def f(x: A) -> None \

# N: def f(x: B) -> None

f(A())

f(B())

@overload

def f(x: 'A') -> None: pass

@overload

def f(x: 'B') -> None: pass

class A: pass

class B: pass

class C: pass

[case testOverloadedFunctionReturnValue]

from foo import *

[file foo.pyi]

from typing import overload

a: A

b: B

if int():

b = f(a) # E: Incompatible types in assignment (expression has type "A", variable has type "B")

if int():

a = f(b) # E: Incompatible types in assignment (expression has type "B", variable has type "A")

if int():

a = f(a)

if int():

b = f(b)

@overload

def f(x: 'A') -> 'A': pass

@overload

def f(x: 'B') -> 'B': pass

class A: pass

class B: pass

[builtins fixtures/tuple.pyi]

[case testCallToOverloadedMethod]

from foo import *

[file foo.pyi]

from typing import overload

A().f(C()) # E: No overload variant of "f" of "A" matches argument type "C" \

# N: Possible overload variants: \

# N: def f(self, x: A) -> None \

# N: def f(self, x: B) -> None

A().f(A())

A().f(B())

class A:

@overload

def f(self, x: 'A') -> None: pass

@overload

def f(self, x: 'B') -> None: pass

class B: pass

class C: pass

[case testOverloadedMethodReturnValue]

from foo import *

[file foo.pyi]

from typing import overload

a: A

b: B

if int():

b = a.f(a) # E: Incompatible types in assignment (expression has type "A", variable has type "B")

if int():

a = a.f(b) # E: Incompatible types in assignment (expression has type "B", variable has type "A")

if int():

a = a.f(a)

if int():

b = a.f(b)

class A:

@overload

def f(self, x: 'A') -> 'A': pass

@overload

def f(self, x: 'B') -> 'B': pass

class B: pass

[builtins fixtures/tuple.pyi]

[case testOverloadsWithDifferentArgumentCounts]

from foo import *

[file foo.pyi]

from typing import overload

a: A

b: B

if int():

a = f(a)

if int():

b = f(a) # E: Incompatible types in assignment (expression has type "A", variable has type "B")

f(b) # E: No overload variant of "f" matches argument type "B" \

# N: Possible overload variants: \

# N: def f(x: A) -> A \

# N: def f(x: B, y: A) -> B

if int():

b = f(b, a)

if int():

a = f(b, a) # E: Incompatible types in assignment (expression has type "B", variable has type "A")

f(a, a) # E: No overload variant of "f" matches argument types "A", "A" \

# N: Possible overload variants: \

# N: def f(x: A) -> A \

# N: def f(x: B, y: A) -> B

f(b, b) # E: No overload variant of "f" matches argument types "B", "B" \

# N: Possible overload variants: \

# N: def f(x: A) -> A \

# N: def f(x: B, y: A) -> B

@overload

def f(x: 'A') -> 'A': pass

@overload

def f(x: 'B', y: 'A') -> 'B': pass

class A: pass

class B: pass

[builtins fixtures/tuple.pyi]

[case testGenericOverloadVariant]

from foo import *

[file foo.pyi]

from typing import overload, TypeVar, Generic

t = TypeVar('t')

ab: A[B]

ac: A[C]

b: B

c: C

if int():

b = f(ab)

c = f(ac)

b = f(ac) # E: Incompatible types in assignment (expression has type "C", variable has type "B")

b = f(b)

c = f(b) # E: Incompatible types in assignment (expression has type "B", variable has type "C")

@overload

def f(x: 'A[t]') -> t: pass

@overload

def f(x: 'B') -> 'B': pass

class A(Generic[t]): pass

class B: pass

class C: pass

[builtins fixtures/tuple.pyi]

[case testOverloadedInit]

from foo import *

[file foo.pyi]

from typing import overload

a: A

b: B

a = A(a)

a = A(b)

a = A(object()) # E: No overload variant of "A" matches argument type "object" \

# N: Possible overload variants: \

# N: def A(a: A) -> A \

# N: def A(b: B) -> A

class A:

@overload

def __init__(self, a: 'A') -> None: pass

@overload

def __init__(self, b: 'B') -> None: pass

class B: pass

[builtins fixtures/tuple.pyi]

[case testIntersectionTypeCompatibility]

from foo import *

[file foo.pyi]

from typing import overload, Callable

o: object

a: A

if int():

a = f # E: Incompatible types in assignment (expression has type overloaded function, variable has type "A")

if int():

o = f

@overload

def f(a: 'A') -> None: pass

@overload

def f(a: Callable[[], None]) -> None: pass

class A: pass

[case testCompatibilityOfIntersectionTypeObjectWithStdType]

from foo import *

[file foo.pyi]

from typing import overload

t: type

a: A

if int():

a = A # E: Incompatible types in assignment (expression has type "type[A]", variable has type "A")

t = A

class A:

@overload

def __init__(self, a: 'A') -> None: pass

@overload

def __init__(self, a: 'B') -> None: pass

class B: pass

[builtins fixtures/tuple.pyi]

[case testOverloadedGetitem]

from foo import *

[file foo.pyi]

from typing import overload

a: int

b: str

if int():

a = A()[a]

if int():

b = A()[a] # E: Incompatible types in assignment (expression has type "int", variable has type "str")

if int():

b = A()[b]

if int():

a = A()[b] # E: Incompatible types in assignment (expression has type "str", variable has type "int")

class A:

@overload

def __getitem__(self, a: int) -> int: pass

@overload

def __getitem__(self, b: str) -> str: pass

[builtins fixtures/tuple.pyi]

[case testOverloadedGetitemWithGenerics]

from foo import *

[file foo.pyi]

from typing import TypeVar, Generic, overload

t = TypeVar('t')

a: A

b: B

c: C[A]

if int():

a = c[a]

b = c[a] # E: Incompatible types in assignment (expression has type "A", variable has type "B")

if int():

a = c[b]

b = c[b] # E: Incompatible types in assignment (expression has type "A", variable has type "B")

class C(Generic[t]):

@overload

def __getitem__(self, a: 'A') -> t: pass

@overload

def __getitem__(self, b: 'B') -> t: pass

class A: pass

class B: pass

[builtins fixtures/tuple.pyi]

[case testImplementingOverloadedMethod]

from foo import *

[file foo.pyi]

from typing import overload

from abc import abstractmethod, ABCMeta

class I(metaclass=ABCMeta):

@overload

@abstractmethod

def f(self) -> None: pass

@overload

@abstractmethod

def f(self, a: 'A') -> None: pass

class A(I):

@overload

def f(self) -> None: pass

@overload

def f(self, a: 'A') -> None: pass

[case testOverloadWithFunctionType]

from foo import *

[file foo.pyi]

from typing import overload, Callable

class A: pass

@overload

def f(x: A) -> None: pass

@overload

def f(x: Callable[[], None]) -> None: pass

f(A())

[builtins fixtures/function.pyi]

[case testVarArgsOverload]

from foo import *

[file foo.pyi]

from typing import overload, Any

@overload

def f(x: 'A', *more: Any) -> 'A': pass

@overload

def f(x: 'B', *more: Any) -> 'A': pass

f(A())

f(A(), A, A)

f(B())

f(B(), B)

f(B(), B, B)

f(object()) # E: No overload variant of "f" matches argument type "object" \

# N: Possible overload variants: \

# N: def f(x: A, *more: Any) -> A \

# N: def f(x: B, *more: Any) -> A

class A: pass

class B: pass

[builtins fixtures/list.pyi]

[case testVarArgsOverload2]

from foo import *

[file foo.pyi]

from typing import overload

@overload

def f(x: 'A', *more: 'B') -> 'A': pass

@overload

def f(x: 'B', *more: 'A') -> 'A': pass

f(A(), B())

f(A(), B(), B())

f(A(), A(), B()) # E: No overload variant of "f" matches argument types "A", "A", "B" \

# N: Possible overload variants: \

# N: def f(x: A, *more: B) -> A \

# N: def f(x: B, *more: A) -> A

f(A(), B(), A()) # E: No overload variant of "f" matches argument types "A", "B", "A" \

# N: Possible overload variants: \

# N: def f(x: A, *more: B) -> A \

# N: def f(x: B, *more: A) -> A

class A: pass

class B: pass

[builtins fixtures/list.pyi]

[case testOverloadWithTypeObject]

from foo import *

[file foo.pyi]

from typing import overload

@overload

def f(a: 'A', t: type) -> None: pass

@overload

def f(a: 'B', t: type) -> None: pass

f(A(), B)

f(B(), A)

class A: pass

class B: pass

[builtins fixtures/function.pyi]

[case testOverloadedInitAndTypeObjectInOverload]

from foo import *

[file foo.pyi]

from typing import overload

@overload

def f(t: type) -> 'A': pass

@overload

def f(t: 'A') -> 'B': pass

a: A

b: B

if int():

a = f(A)

if int():

b = f(a)

if int():

b = f(A) # E: Incompatible types in assignment (expression has type "A", variable has type "B")

if int():

a = f(a) # E: Incompatible types in assignment (expression has type "B", variable has type "A")

class A:

@overload

def __init__(self) -> None: pass

@overload

def __init__(self, a: 'A') -> None: pass

class B:

pass

[builtins fixtures/tuple.pyi]

[case testOverlappingErasedSignatures]

from foo import *

[file foo.pyi]

from typing import overload, List

@overload

def f(a: List[int]) -> int: pass

@overload

def f(a: List[str]) -> int: pass

list_int = [] # type: List[int]

list_str = [] # type: List[str]

list_object = [] # type: List[object]

n = f(list_int)

m = f(list_str)

def p(): n, m # Prevent redefinition

n = 1

m = 1

n = 'x' # E: Incompatible types in assignment (expression has type "str", variable has type "int")

m = 'x' # E: Incompatible types in assignment (expression has type "str", variable has type "int")

f(list_object) # E: Argument 1 to "f" has incompatible type "list[object]"; expected "list[int]"

[builtins fixtures/list.pyi]

[case testOverlappingOverloadSignatures]

from foo import *

[file foo.pyi]

from typing import overload

class A: pass

class B(A): pass

@overload

def f(x: B) -> int: pass # E: Overloaded function signatures 1 and 2 overlap with incompatible return types

@overload

def f(x: A) -> str: pass

[case testContravariantOverlappingOverloadSignatures]

from foo import *

[file foo.pyi]

from typing import overload

class A: pass

class B(A): pass

@overload

def f(x: A) -> A: pass

@overload

def f(x: B) -> B: pass # E: Overloaded function signature 2 will never be matched: signature 1's parameter type(s) are the same or broader

[case testPartiallyCovariantOverlappingOverloadSignatures]

from foo import *

[file foo.pyi]

from typing import overload

class A: pass

class B(A): pass

@overload

def f(x: B) -> A: pass # E: Overloaded function signatures 1 and 2 overlap with incompatible return types

@overload

def f(x: A) -> B: pass

[case testPartiallyContravariantOverloadSignatures]

from foo import *

[file foo.pyi]

from typing import overload

class A: pass

class B(A): pass

@overload

def g(x: A) -> int: pass

@overload

def g(x: B) -> str: pass # E: Overloaded function signature 2 will never be matched: signature 1's parameter type(s) are the same or broader

[case testCovariantOverlappingOverloadSignatures]

from foo import *

[file foo.pyi]

from typing import overload

class A: pass

class B(A): pass

@overload

def g(x: B) -> B: pass

@overload

def g(x: A) -> A: pass

[case testCovariantOverlappingOverloadSignaturesWithSomeSameArgTypes]

from foo import *

[file foo.pyi]

from typing import overload

class A: pass

class B(A): pass

@overload

def g(x: int, y: B) -> B: pass

@overload

def g(x: int, y: A) -> A: pass

[case testCovariantOverlappingOverloadSignaturesWithAnyType]

from foo import *

[file foo.pyi]

from typing import Any, overload

@overload

def g(x: int) -> int: pass

@overload

def g(x: Any) -> Any: pass

[case testContravariantOverlappingOverloadSignaturesWithAnyType]

from foo import *

[file foo.pyi]

from typing import Any, overload

@overload

def g(x: Any) -> Any: pass

@overload

def g(x: int) -> int: pass # E: Overloaded function signature 2 will never be matched: signature 1's parameter type(s) are the same or broader

[case testOverloadedLtAndGtMethods]

from foo import *

[file foo.pyi]

from typing import overload

class A:

def __lt__(self, x: A) -> int: pass

def __gt__(self, x: A) -> int: pass

class B:

@overload

def __lt__(self, x: B) -> int: pass

@overload

def __lt__(self, x: A) -> int: pass

@overload

def __gt__(self, x: B) -> int: pass

@overload

def __gt__(self, x: A) -> int: pass

A() < A()

A() < B()

B() < A()

B() < B()

A() < object() # E: Unsupported operand types for < ("A" and "object")

B() < object() # E: No overload variant of "__lt__" of "B" matches argument type "object" \

# N: Possible overload variants: \

# N: def __lt__(self, B, /) -> int \

# N: def __lt__(self, A, /) -> int

[case testOverloadedForwardMethodAndCallingReverseMethod]

from foo import *

[file foo.pyi]

from typing import overload

class A:

@overload

def __add__(self, x: 'A') -> int: pass

@overload

def __add__(self, x: int) -> int: pass

class B:

def __radd__(self, x: A) -> int: pass

A() + A()

A() + 1

A() + B()

A() + '' # E: No overload variant of "__add__" of "A" matches argument type "str" \

# N: Possible overload variants: \

# N: def __add__(self, A, /) -> int \

# N: def __add__(self, int, /) -> int

[case testOverrideOverloadSwapped]

from foo import *

[file foo.pyi]

from typing import overload

class Parent:

@overload

def f(self, x: int) -> int: ...

@overload

def f(self, x: str) -> str: ...

class Child(Parent):

@overload # E: Signature of "f" incompatible with supertype "Parent" \

# N: Overload variants must be defined in the same order as they are in "Parent"