-- Methods

-- -------

[case testMethodCall]

class A:

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

class B:

def bar(self, x: 'B', y: A) -> None: pass

a: A

b: B

a.foo(B()) # E: Argument 1 to "foo" of "A" has incompatible type "B"; expected "A"

a.bar(B(), A()) # E: "A" has no attribute "bar"

a.foo(A())

b.bar(B(), A())

[case testMethodCallWithSubtype]

class A:

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

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

class B(A): pass

a: A

a.foo(A())

a.foo(B())

a.bar(A()) # E: Argument 1 to "bar" of "A" has incompatible type "A"; expected "B"

a.bar(B())

[case testInheritingMethod]

class A:

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

class B(A): pass

a: B

a.foo(A()) # Fail

a.foo(B())

[targets __main__, __main__.A.foo]

[out]

main:6: error: Argument 1 to "foo" of "A" has incompatible type "A"; expected "B"

[case testMethodCallWithInvalidNumberOfArguments]

class A:

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

a: A

a.foo() # Fail

a.foo(object(), A()) # Fail

[out]

main:5: error: Missing positional argument "x" in call to "foo" of "A"

main:6: error: Too many arguments for "foo" of "A"

main:6: error: Argument 1 to "foo" of "A" has incompatible type "object"; expected "A"

[case testMethodBody]

import typing

class A:

def f(self) -> None:

a = object() # type: A # Fail

[out]

main:4: error: Incompatible types in assignment (expression has type "object", variable has type "A")

[case testMethodArguments]

import typing

class A:

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

if int():

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

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

a = A()

b = B()

a = a

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

class B: pass

[out]

[case testReturnFromMethod]

import typing

class A:

def f(self) -> 'A':

return B() # Fail

return A()

class B: pass

[out]

main:4: error: Incompatible return value type (got "B", expected "A")

[case testSelfArgument]

import typing

class A:

def f(self) -> None:

o = self # type: B # Fail

self.g() # Fail

a = self # type: A

self.f()

class B: pass

[out]

main:4: error: Incompatible types in assignment (expression has type "A", variable has type "B")

main:5: error: "A" has no attribute "g"

[case testAssignToMethodViaInstance]

import typing

class A:

def f(self): pass

A().f = None # E: Cannot assign to a method \

# E: Incompatible types in assignment (expression has type "None", variable has type "Callable[[], Any]")

[case testOverrideAttributeWithMethod]

# This was crashing:

# https://github.com/python/mypy/issues/10134

from typing import Protocol

class Base:

__hash__: None = None

class Derived(Base):

def __hash__(self) -> int: # E: Signature of "__hash__" incompatible with supertype "Base" \

# N: Superclass: \

# N: None \

# N: Subclass: \

# N: def __hash__(self) -> int

pass

# Correct:

class CallableProtocol(Protocol):

def __call__(self, arg: int) -> int:

pass

class CorrectBase:

attr: CallableProtocol

class CorrectDerived(CorrectBase):

def attr(self, arg: int) -> int:

pass

[case testOverrideMethodWithAttribute]

# The reverse should not crash as well:

from typing import Callable

class Base:

def __hash__(self) -> int:

pass

class Derived(Base):

__hash__ = 1 # E: Incompatible types in assignment (expression has type "int", base class "Base" defined the type as "Callable[[], int]")

[case testOverridePartialAttributeWithMethod]

# This was crashing: https://github.com/python/mypy/issues/11686.

class Base:

def __init__(self, arg: int):

self.partial_type = [] # E: Need type annotation for "partial_type" (hint: "partial_type: list[<type>] = ...")

self.force_deferral = []

# Force inference of the `force_deferral` attribute in `__init__` to be

# deferred to a later pass by providing a definition in another context,

# which means `partial_type` remains only partially inferred.

force_deferral = [] # E: Need type annotation for "force_deferral" (hint: "force_deferral: list[<type>] = ...")

class Derived(Base):

def partial_type(self) -> int: # E: Signature of "partial_type" incompatible with supertype "Base" \

# N: Superclass: \

# N: list[Any] \

# N: Subclass: \

# N: def partial_type(self) -> int

...

-- Attributes

-- ----------

[case testReferToInvalidAttribute]

class A:

def __init__(self) -> None:

self.x = object()

a: A

a.y # E: "A" has no attribute "y"

a.y = object() # E: "A" has no attribute "y"

a.x

a.x = object()

[case testReferToInvalidAttributeUnannotatedInit]

class A:

def __init__(self):

self.x = object()

a: A

a.y # E: "A" has no attribute "y"

a.y = object() # E: "A" has no attribute "y"

a.x

a.x = object()

[case testArgumentTypeInference]

class A:

def __init__(self, aa: 'A', bb: 'B') -> None:

self.a = aa

self.b = bb

class B: pass

a: A

b: B

a.a = b # Fail

a.b = a # Fail

b.a # Fail

a.a = a

a.b = b

[out]

main:9: error: Incompatible types in assignment (expression has type "B", variable has type "A")

main:10: error: Incompatible types in assignment (expression has type "A", variable has type "B")

main:11: error: "B" has no attribute "a"

[case testExplicitAttributeInBody]

class A:

x: A

a: A

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

a.x = A()

[case testAttributeDefinedInNonInitMethod]

import typing

class A:

def f(self) -> None:

self.x = 1

self.y = ''

self.x = 1

a = A()

a.x = 1

a.y = ''

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

a.z = 0 # E: "A" has no attribute "z"

[case testInheritanceAndAttributeAssignment]

import typing

class A:

def f(self) -> None:

self.x = 0

class B(A):

def f(self) -> None:

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

[targets __main__, __main__.A.f, __main__.B.f]

[case testAssignmentToAttributeInMultipleMethods]

import typing

class A:

def f(self) -> None:

self.x = 0

def g(self) -> None:

self.x = '' # Fail

def __init__(self) -> None:

self.x = '' # Fail

[out]

main:6: error: Incompatible types in assignment (expression has type "str", variable has type "int")

main:8: error: Incompatible types in assignment (expression has type "str", variable has type "int")

[case testClassNamesDefinedOnSelUsedInClassBody]

class A(object):

def f(self):

self.attr = 1

attr = 0

class B(object):

attr = 0

def f(self):

self.attr = 1

class C(object):

attr = 0

def f(self):

self.attr = 1

attr = 0

class D(object):

def g(self):

self.attr = 1

attr = 0

def f(self):

self.attr = 1

[out]

[case testClassNamesDefinedOnSelUsedInClassBodyReveal]

class A(object):

def f(self) -> None:

self.attr = 1

attr # E: Name "attr" is not defined

class B(object):

attr = 0

def f(self) -> None:

reveal_type(self.attr) # N: Revealed type is "builtins.int"

[out]

-- Method overriding

-- -----------------

[case testMethodOverridingWithIdenticalSignature]

import typing

class A:

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

def g(self, x: 'B' , y: object) -> 'A': pass

def h(self) -> None: pass

class B(A):

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

def g(self, x: 'B' , y: object) -> A: pass

def h(self) -> None: pass

[out]

[case testMethodOverridingWithCovariantType]

import typing

class A:

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

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

class B(A):

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

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

[out]

[case testMethodOverridingWithIncompatibleTypes]

import typing

class A:

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

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

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

class B(A):

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

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

def h(self, x: A, y: 'B') -> object: pass # Fail

[out]

main:7: error: Argument 1 of "f" is incompatible with supertype "A"; supertype defines the argument type as "A"

main:7: note: This violates the Liskov substitution principle

main:7: note: See https://mypy.readthedocs.io/en/stable/common_issues.html#incompatible-overrides

main:9: error: Return type "object" of "h" incompatible with return type "A" in supertype "A"

[case testMethodOverridingWithIncompatibleTypesOnMultipleLines]

class A:

def f(self, x: int, y: str) -> None: pass

class B(A):

def f(

self,

x: int,

y: bool,

) -> None:

pass

[out]

main:7: error: Argument 2 of "f" is incompatible with supertype "A"; supertype defines the argument type as "str"

main:7: note: This violates the Liskov substitution principle

main:7: note: See https://mypy.readthedocs.io/en/stable/common_issues.html#incompatible-overrides

[case testMultiLineMethodOverridingWithIncompatibleTypesIgnorableAtArgument]

class A:

def f(self, x: int, y: str) -> None: pass

class B(A):

def f(

self,

x: int,

y: bool, # type: ignore[override]

) -> None:

pass

[case testMultiLineMethodOverridingWithIncompatibleTypesIgnorableAtDefinition]

class A:

def f(self, x: int, y: str) -> None: pass

class B(A):

def f( # type: ignore[override]

self,

x: int,

y: bool,

) -> None:

pass

[case testMultiLineMethodOverridingWithIncompatibleTypesWrongIgnore]

class A:

def f(self, x: int, y: str) -> None: pass

class B(A):

def f( # type: ignore[return-type]

self,

x: int,

y: bool,

) -> None:

pass

[out]

main:7: error: Argument 2 of "f" is incompatible with supertype "A"; supertype defines the argument type as "str"

main:7: note: This violates the Liskov substitution principle

main:7: note: See https://mypy.readthedocs.io/en/stable/common_issues.html#incompatible-overrides

[case testEqMethodsOverridingWithNonObjects]

class A:

def __eq__(self, other: A) -> bool: pass # Fail

[builtins fixtures/plugin_attrs.pyi]

[out]

main:2: error: Argument 1 of "__eq__" is incompatible with supertype "builtins.object"; supertype defines the argument type as "object"

main:2: note: This violates the Liskov substitution principle

main:2: note: See https://mypy.readthedocs.io/en/stable/common_issues.html#incompatible-overrides

main:2: note: It is recommended for "__eq__" to work with arbitrary objects, for example:

main:2: note: def __eq__(self, other: object) -> bool:

main:2: note: if not isinstance(other, A):

main:2: note: return NotImplemented

main:2: note: return <logic to compare two A instances>

[case testMethodOverridingWithIncompatibleArgumentCount]

import typing

class A:

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

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

class B(A):

def f(self, x: A, y: A) -> None: pass # Fail

def g(self, x: A) -> A: pass # Fail

[out]

main:6: error: Signature of "f" incompatible with supertype "A"

main:6: note: Superclass:

main:6: note: def f(self, x: A) -> None

main:6: note: Subclass:

main:6: note: def f(self, x: A, y: A) -> None

main:7: error: Signature of "g" incompatible with supertype "A"

main:7: note: Superclass:

main:7: note: def g(self, x: A, y: B) -> A

main:7: note: Subclass:

main:7: note: def g(self, x: A) -> A

[case testMethodOverridingAcrossDeepInheritanceHierarchy1]

import typing

class A:

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

class B(A): pass

class C(B): # with gap in implementations

def f(self, x: 'C') -> None: # Fail

pass

[out]

main:6: error: Argument 1 of "f" is incompatible with supertype "A"; supertype defines the argument type as "B"

main:6: note: This violates the Liskov substitution principle

main:6: note: See https://mypy.readthedocs.io/en/stable/common_issues.html#incompatible-overrides

[case testMethodOverridingAcrossDeepInheritanceHierarchy2]

import typing

class A:

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

class B(A):

def f(self) -> 'C': pass

class C(B): # with multiple implementations

def f(self) -> B: # Fail

pass

[out]

main:7: error: Return type "B" of "f" incompatible with return type "C" in supertype "B"

[case testMethodOverridingWithVoidReturnValue]

import typing

class A:

def f(self) -> None: pass

def g(self) -> 'A': pass

class B(A):

def f(self) -> A: pass # Fail

def g(self) -> None: pass # Fail

[out]

main:6: error: Return type "A" of "f" incompatible with return type "None" in supertype "A"

main:7: error: Return type "None" of "g" incompatible with return type "A" in supertype "A"

[case testOverride__new__WithDifferentSignature]

class A:

def __new__(cls, x: int) -> A:

pass

class B(A):

def __new__(cls) -> B:

pass

[case testOverride__new__WithLiteralReturnPassing]

from typing import Literal

class Falsy:

def __bool__(self) -> Literal[False]: pass

reveal_type(bool(Falsy())) # N: Revealed type is "Literal[False]"

reveal_type(int()) # N: Revealed type is "Literal[0]"

[builtins fixtures/literal__new__.pyi]

[typing fixtures/typing-medium.pyi]

[case testOverride__new__WithLiteralReturnFailing]

from typing import Literal

class Foo:

def __new__(cls) -> Literal[1]: pass # E: Incompatible return type for "__new__" (returns "Literal[1]", but must return a subtype of "Foo")

[builtins fixtures/__new__.pyi]

[typing fixtures/typing-medium.pyi]

[case testOverride__new__AndCallObject]

from typing import TypeVar, Generic

class A:

def __new__(cls, x: int) -> 'A':

return object.__new__(cls)

T = TypeVar('T')

class B(Generic[T]):

def __new__(cls, foo: T) -> 'B[T]':

x = object.__new__(cls)

# object.__new__ doesn't have a great type :(

reveal_type(x) # N: Revealed type is "Any"

return x

[builtins fixtures/__new__.pyi]

[case testInnerFunctionNotOverriding]

class A:

def f(self) -> int: pass

class B(A):

def g(self) -> None:

def f(self) -> str: pass

[case testOverride__init_subclass__WithDifferentSignature]

class A:

def __init_subclass__(cls, x: int) -> None: pass

class B(A): # E: Missing positional argument "x" in call to "__init_subclass__" of "A"

def __init_subclass__(cls) -> None: pass

[case testOverrideWithDecorator]

from typing import Callable

def int_to_none(f: Callable[..., int]) -> Callable[..., None]: ...

def str_to_int(f: Callable[..., str]) -> Callable[..., int]: ...

class A:

def f(self) -> None: pass

def g(self) -> str: pass

def h(self) -> None: pass

class B(A):

@int_to_none

def f(self) -> int: pass

@str_to_int

def g(self) -> str: pass # Fail

@int_to_none

@str_to_int

def h(self) -> str: pass

[out]

main:15: error: Signature of "g" incompatible with supertype "A"

main:15: note: Superclass:

main:15: note: def g(self) -> str

main:15: note: Subclass:

main:15: note: def g(*Any, **Any) -> int

[case testOverrideDecorated]

from typing import Callable

def str_to_int(f: Callable[..., str]) -> Callable[..., int]: ...

class A:

@str_to_int

def f(self) -> str: pass

@str_to_int

def g(self) -> str: pass

@str_to_int

def h(self) -> str: pass

class B(A):

def f(self) -> int: pass

def g(self) -> str: pass # Fail

@str_to_int

def h(self) -> str: pass

[out]

main:15: error: Signature of "g" incompatible with supertype "A"

main:15: note: Superclass:

main:15: note: def g(*Any, **Any) -> int

main:15: note: Subclass:

main:15: note: def g(self) -> str

[case testOverrideWithDecoratorReturningAny]

def dec(f): pass

class A:

def f(self) -> str: pass

class B(A):

@dec

def f(self) -> int: pass

[case testOverrideWithDecoratorReturningCallable]

from typing import Any, Callable, TypeVar

class Base:

def get(self, a: str) -> None: ...

def dec(fn: Any) -> Callable[[Any, int], None]: ...

class Derived(Base):

@dec

def get(self) -> None: ... # E: Argument 1 of "get" is incompatible with supertype "Base"; supertype defines the argument type as "str" \

# N: This violates the Liskov substitution principle \

# N: See https://mypy.readthedocs.io/en/stable/common_issues.html#incompatible-overrides

[builtins fixtures/tuple.pyi]

[case testOverrideWithDecoratorReturningCallable2]

# flags: --pretty

from typing import Any, Callable, TypeVar

_C = TypeVar("_C", bound=Callable[..., Any])

def infer_signature(f: _C) -> Callable[[Any], _C]: ...

class Base:

def get(self, a: str, b: str, c: str) -> None: ...

def post(self, a: str, b: str) -> None: ...

# Third argument incompatible

def get(self, a: str, b: str, c: int) -> None: ...

# Second argument incompatible - still should not map to **kwargs

def post(self, a: str, b: int) -> None: ...

class Derived(Base):

@infer_signature(get)

def get(self, *args: Any, **kwargs: Any) -> None: ...

@infer_signature(post)

def post(self, *args: Any, **kwargs: Any) -> None: ...

[builtins fixtures/tuple.pyi]

[out]

main:20: error: Argument 3 of "get" is incompatible with supertype "Base"; supertype defines the argument type as "str"

def get(self, *args: Any, **kwargs: Any) -> None: ...

^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

main:20: note: This violates the Liskov substitution principle

main:20: note: See https://mypy.readthedocs.io/en/stable/common_issues.html#incompatible-overrides

main:23: error: Argument 2 of "post" is incompatible with supertype "Base"; supertype defines the argument type as "str"

def post(self, *args: Any, **kwargs: Any) -> None: ...

^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

main:23: note: This violates the Liskov substitution principle

main:23: note: See https://mypy.readthedocs.io/en/stable/common_issues.html#incompatible-overrides

[case testOverrideWithDecoratorReturningInstance]

def dec(f) -> str: pass

class A:

def f(self) -> str: pass

@dec

def g(self) -> int: pass

@dec

def h(self) -> int: pass

class B(A):

@dec

def f(self) -> int: pass # E: Signature of "f" incompatible with supertype "A" \

# N: Superclass: \

# N: def f(self) -> str \

# N: Subclass: \

# N: str

def g(self) -> int: pass # E: Signature of "g" incompatible with supertype "A" \

# N: Superclass: \

# N: str \

# N: Subclass: \

# N: def g(self) -> int

@dec

def h(self) -> str: pass

[case testOverrideIncompatibleWithMultipleSupertypes]

class A:

def f(self, *, a: int) -> None:

return

class B(A):

def f(self, *, b: int) -> None: # E: Signature of "f" incompatible with supertype "A" \

# N: Superclass: \

# N: def f(self, *, a: int) -> None \

# N: Subclass: \

# N: def f(self, *, b: int) -> None

return

class C(B):

def f(self, *, c: int) -> None: # E: Signature of "f" incompatible with supertype "B" \

# N: Superclass: \

# N: def f(self, *, b: int) -> None \

# N: Subclass: \

# N: def f(self, *, c: int) -> None \

# E: Signature of "f" incompatible with supertype "A" \

# N: Superclass: \

# N: def f(self, *, a: int) -> None \

# N: Subclass: \

# N: def f(self, *, c: int) -> None

return

[case testOverrideStaticMethodWithStaticMethod]

class A:

@staticmethod

def f(x: int, y: str) -> None: pass

@staticmethod

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

class B(A):

@staticmethod

def f(x: int, y: str) -> None: pass

@staticmethod

def g(x: str, y: str) -> None: pass # E: Argument 1 of "g" is incompatible with supertype "A"; supertype defines the argument type as "int" \

# N: This violates the Liskov substitution principle \

# N: See https://mypy.readthedocs.io/en/stable/common_issues.html#incompatible-overrides

[builtins fixtures/classmethod.pyi]

[case testOverrideClassMethodWithClassMethod]

class A:

@classmethod

def f(cls, x: int, y: str) -> None: pass

@classmethod

def g(cls, x: int, y: str) -> None: pass

class B(A):

@classmethod

def f(cls, x: int, y: str) -> None: pass

@classmethod

def g(cls, x: str, y: str) -> None: pass # E: Argument 1 of "g" is incompatible with supertype "A"; supertype defines the argument type as "int" \

# N: This violates the Liskov substitution principle \

# N: See https://mypy.readthedocs.io/en/stable/common_issues.html#incompatible-overrides

[builtins fixtures/classmethod.pyi]

[case testOverrideClassMethodWithStaticMethod]

class A:

@classmethod

def f(cls, x: int) -> None: pass

@classmethod

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

@classmethod

def h(cls) -> int: pass

class B(A):

@staticmethod

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

@staticmethod

def g(x: str) -> int: pass # E: Argument 1 of "g" is incompatible with supertype "A"; supertype defines the argument type as "int" \

# N: This violates the Liskov substitution principle \

# N: See https://mypy.readthedocs.io/en/stable/common_issues.html#incompatible-overrides

@staticmethod

def h() -> int: pass

[builtins fixtures/classmethod.pyi]

[case testOverrideStaticMethodWithClassMethod]

class A:

@staticmethod

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

@staticmethod

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

@staticmethod

def h() -> int: pass

class B(A):

@classmethod

def f(cls, x: int) -> None: pass

@classmethod

def g(cls, x: int) -> int: pass # E: Argument 1 of "g" is incompatible with supertype "A"; supertype defines the argument type as "str" \

# N: This violates the Liskov substitution principle \

# N: See https://mypy.readthedocs.io/en/stable/common_issues.html#incompatible-overrides

@classmethod

def h(cls) -> int: pass

[builtins fixtures/classmethod.pyi]

[case testOverrideReplaceMethod]

# flags: --show-error-codes

from typing import Optional

from typing_extensions import Self

class A:

def __replace__(self, x: Optional[str]) -> Self: pass

class B(A):

def __replace__(self, x: str) -> Self: pass # E: \

# E: Argument 1 of "__replace__" is incompatible with supertype "A"; supertype defines the argument type as "str | None" [override] \

# N: This violates the Liskov substitution principle \

# N: See https://mypy.readthedocs.io/en/stable/common_issues.html#incompatible-overrides

[builtins fixtures/tuple.pyi]

[case testAllowCovarianceInReadOnlyAttributes]

from typing import Callable, TypeVar

T = TypeVar('T')

class X:

pass

class Y(X):

pass

def dec(f: Callable[..., T]) -> T: pass

class A:

@dec

def f(self) -> X: pass

class B(A):

@dec

def f(self) -> Y: pass

[case testOverrideCallableAttributeWithMethod]

from typing import Callable

class A:

f1: Callable[[str], None]

f2: Callable[[str], None]

f3: Callable[[str], None]

class B(A):

def f1(self, x: object) -> None:

pass

@classmethod

def f2(cls, x: object) -> None:

pass

@staticmethod

def f3(x: object) -> None:

pass

[builtins fixtures/classmethod.pyi]

[case testOverrideCallableAttributeWithMethodMutableOverride]

# flags: --enable-error-code=mutable-override

from typing import Callable

class A:

f1: Callable[[str], None]

f2: Callable[[str], None]

f3: Callable[[str], None]

class B(A):

def f1(self, x: object) -> None: pass # E: Covariant override of a mutable attribute (base class "A" defined the type as "Callable[[str], None]", override has type "Callable[[object], None]")

@classmethod

def f2(cls, x: object) -> None: pass # E: Covariant override of a mutable attribute (base class "A" defined the type as "Callable[[str], None]", override has type "Callable[[object], None]")

@staticmethod

def f3(x: object) -> None: pass # E: Covariant override of a mutable attribute (base class "A" defined the type as "Callable[[str], None]", override has type "Callable[[object], None]")

[builtins fixtures/classmethod.pyi]

[case testOverrideCallableAttributeWithSettableProperty]

from typing import Callable

class A:

f: Callable[[str], None]

class B(A):

@property

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

@f.setter

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

[builtins fixtures/property.pyi]

[case testOverrideCallableAttributeWithSettablePropertyMutableOverride]

# flags: --enable-error-code=mutable-override

from typing import Callable

class A:

f: Callable[[str], None]

class B(A):

@property

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

@f.setter

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

[builtins fixtures/property.pyi]

[case testOverrideCallableUnionAttributeWithMethod]

from typing import Callable, Union

class A:

f1: Union[Callable[[str], str], str]

f2: Union[Callable[[str], str], str]

f3: Union[Callable[[str], str], str]

f4: Union[Callable[[str], str], str]

class B(A):

def f1(self, x: str) -> str:

pass

def f2(self, x: object) -> str:

pass

@classmethod

def f3(cls, x: str) -> str:

pass

@staticmethod

def f4(x: str) -> str:

pass

[builtins fixtures/classmethod.pyi]

[case testOverrideCallableUnionAttributeWithMethodMutableOverride]

# flags: --enable-error-code=mutable-override

from typing import Callable, Union

class A:

f1: Union[Callable[[str], str], str]

f2: Union[Callable[[str], str], str]

f3: Union[Callable[[str], str], str]

f4: Union[Callable[[str], str], str]

class B(A):

def f1(self, x: str) -> str: # E: Covariant override of a mutable attribute (base class "A" defined the type as "Callable[[str], str] | str", override has type "Callable[[str], str]")

pass

def f2(self, x: object) -> str: # E: Covariant override of a mutable attribute (base class "A" defined the type as "Callable[[str], str] | str", override has type "Callable[[object], str]")

pass

@classmethod

def f3(cls, x: str) -> str: # E: Covariant override of a mutable attribute (base class "A" defined the type as "Callable[[str], str] | str", override has type "Callable[[str], str]")

pass

@staticmethod

def f4(x: str) -> str: # E: Covariant override of a mutable attribute (base class "A" defined the type as "Callable[[str], str] | str", override has type "Callable[[str], str]")

pass

[builtins fixtures/classmethod.pyi]

-- Constructors

-- ------------

[case testTrivialConstructor]

class A:

def __init__(self) -> None: pass

a = A() # type: A

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

class B: pass

[case testConstructor]

class A:

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

class B: pass

a = A(B()) # type: A

aa = A(object()) # type: A # E: Argument 1 to "A" has incompatible type "object"; expected "B"

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

[case testConstructorWithTwoArguments]

class A:

def __init__(self, x: 'B', y: 'C') -> None: pass

class B: pass

class C(B): pass

a = A(C(), B()) # type: A # E: Argument 2 to "A" has incompatible type "B"; expected "C"

[case testInheritedConstructor]

class B(A): pass

class C: pass

class D: pass

b = B(C()) # type: B

a = B(D()) # type: A # E: Argument 1 to "B" has incompatible type "D"; expected "C"

class A:

def __init__(self, x: 'C') -> None: pass

[case testOverridingWithIncompatibleConstructor]

class A:

def __init__(self, x: 'C') -> None: pass

class B(A):

def __init__(self) -> None: pass

class C: pass

A() # E: Missing positional argument "x" in call to "A"

B(C()) # E: Too many arguments for "B"

A(C())

B()

[case testConstructorWithReturnValueType]

import typing

class A:

def __init__(self) -> 'A': pass

[out]

main:3: error: The return type of "__init__" must be None

[case testConstructorWithImplicitReturnValueType]

import typing

class A:

def __init__(self, x: int): pass

[out]

[case testDecoratedConstructorWithImplicitReturnValueType]

import typing

from typing import Callable

def deco(fn: Callable) -> Callable:

return fn

class A:

@deco

def __init__(self, x: int): pass

[out]

[case testOverloadedConstructorWithImplicitReturnValueType]

from foo import *

[file foo.pyi]

from typing import overload

class Foo:

@overload

def __init__(self, a: int):

pass