-- Simple protocol types

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

[case testCannotInstantiateProtocol]

from typing import Protocol

class P(Protocol):

def meth(self) -> None:

pass

P() # E: Cannot instantiate protocol class "P"

[case testSimpleProtocolOneMethod]

from typing import Protocol

class P(Protocol):

def meth(self) -> None:

pass

class B: pass

class C:

def meth(self) -> None:

pass

x: P

def fun(x: P) -> None:

x.meth()

x.meth(x) # E: Too many arguments for "meth" of "P"

x.bad # E: "P" has no attribute "bad"

x = C()

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

fun(C())

fun(B()) # E: Argument 1 to "fun" has incompatible type "B"; expected "P"

def fun2() -> P:

return C()

def fun3() -> P:

return B() # E: Incompatible return value type (got "B", expected "P")

[case testSimpleProtocolOneAbstractMethod]

from typing import Protocol

from abc import abstractmethod

class P(Protocol):

@abstractmethod

def meth(self) -> None:

pass

class B: pass

class C:

def meth(self) -> None:

pass

class D(B):

def meth(self) -> None:

pass

x: P

def fun(x: P) -> None:

x.meth()

x.meth(x) # E: Too many arguments for "meth" of "P"

x.bad # E: "P" has no attribute "bad"

x = C()

x = D()

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

fun(C())

fun(D())

fun(B()) # E: Argument 1 to "fun" has incompatible type "B"; expected "P"

fun(x)

[case testProtocolMethodBodies]

from typing import Protocol, List

class P(Protocol):

def meth(self) -> int:

return 'no way' # E: Incompatible return value type (got "str", expected "int")

# explicit ellipsis is OK in protocol methods

class P2(Protocol):

def meth2(self) -> List[int]:

...

[builtins fixtures/list.pyi]

[case testSimpleProtocolOneMethodOverride]

from typing import Protocol, Union

class P(Protocol):

def meth(self) -> Union[int, str]:

pass

class SubP(P, Protocol):

def meth(self) -> int:

pass

class B: pass

class C:

def meth(self) -> int:

pass

z: P

x: SubP

def fun(x: SubP) -> str:

x.bad # E: "SubP" has no attribute "bad"

return x.meth() # E: Incompatible return value type (got "int", expected "str")

z = x

x = C()

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

reveal_type(fun(C())) # E: Revealed type is 'builtins.str'

fun(B()) # E: Argument 1 to "fun" has incompatible type "B"; expected "SubP"

[case testSimpleProtocolTwoMethodsMerge]

from typing import Protocol

class P1(Protocol):

def meth1(self) -> int:

pass

class P2(Protocol):

def meth2(self) -> str:

pass

class P(P1, P2, Protocol): pass

class B: pass

class C1:

def meth1(self) -> int:

pass

class C2(C1):

def meth2(self) -> str:

pass

class C:

def meth1(self) -> int:

pass

def meth2(self) -> str:

pass

class AnotherP(Protocol):

def meth1(self) -> int:

pass

def meth2(self) -> str:

pass

x: P

reveal_type(x.meth1()) # E: Revealed type is 'builtins.int'

reveal_type(x.meth2()) # E: Revealed type is 'builtins.str'

c: C

c1: C1

c2: C2

y: AnotherP

if int():

x = c

if int():

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

if int():

x = c1 # E: Incompatible types in assignment (expression has type "C1", variable has type "P") \

# N: 'C1' is missing following 'P' protocol member: \

# N: meth2

if int():

x = c2

if int():

x = y

if int():

y = x

[case testSimpleProtocolTwoMethodsExtend]

from typing import Protocol

class P1(Protocol):

def meth1(self) -> int:

pass

class P2(P1, Protocol):

def meth2(self) -> str:

pass

class Cbad:

def meth1(self) -> int:

pass

class C:

def meth1(self) -> int:

pass

def meth2(self) -> str:

pass

x: P2

reveal_type(x.meth1()) # E: Revealed type is 'builtins.int'

reveal_type(x.meth2()) # E: Revealed type is 'builtins.str'

if int():

x = C() # OK

if int():

x = Cbad() # E: Incompatible types in assignment (expression has type "Cbad", variable has type "P2") \

# N: 'Cbad' is missing following 'P2' protocol member: \

# N: meth2

[case testProtocolMethodVsAttributeErrors]

from typing import Protocol

class P(Protocol):

def meth(self) -> int:

pass

class C:

meth: int

x: P = C() # E: Incompatible types in assignment (expression has type "C", variable has type "P") \

# N: Following member(s) of "C" have conflicts: \

# N: meth: expected "Callable[[], int]", got "int"

[case testProtocolMethodVsAttributeErrors2]

from typing import Protocol

class P(Protocol):

@property

def meth(self) -> int:

pass

class C:

def meth(self) -> int:

pass

x: P = C() # E: Incompatible types in assignment (expression has type "C", variable has type "P") \

# N: Following member(s) of "C" have conflicts: \

# N: meth: expected "int", got "Callable[[], int]"

[builtins fixtures/property.pyi]

[case testCannotAssignNormalToProtocol]

from typing import Protocol

class P(Protocol):

def meth(self) -> int:

pass

class C:

def meth(self) -> int:

pass

x: C

y: P

x = y # E: Incompatible types in assignment (expression has type "P", variable has type "C")

[case testIndependentProtocolSubtyping]

from typing import Protocol

class P1(Protocol):

def meth(self) -> int:

pass

class P2(Protocol):

def meth(self) -> int:

pass

x1: P1

x2: P2

x1 = x2

x2 = x1

def f1(x: P1) -> None: pass

def f2(x: P2) -> None: pass

f1(x2)

f2(x1)

[case testNoneDisablesProtocolImplementation]

from typing import Protocol

class MyHashable(Protocol):

def __my_hash__(self) -> int:

return 0

class C:

__my_hash__ = None

var: MyHashable = C() # E: Incompatible types in assignment (expression has type "C", variable has type "MyHashable")

[case testNoneDisablesProtocolSubclassingWithStrictOptional]

# flags: --strict-optional

from typing import Protocol

class MyHashable(Protocol):

def __my_hash__(self) -> int:

return 0

class C(MyHashable):

__my_hash__ = None # E: Incompatible types in assignment \

(expression has type "None", base class "MyHashable" defined the type as "Callable[[MyHashable], int]")

[case testProtocolsWithNoneAndStrictOptional]

# flags: --strict-optional

from typing import Protocol

class P(Protocol):

x = 0 # type: int

class C:

x = None

x: P = C() # Error!

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

f(C()) # Error!

[out]

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

main:9: note: Following member(s) of "C" have conflicts:

main:9: note: x: expected "int", got "None"

main:11: error: Argument 1 to "f" has incompatible type "C"; expected "P"

main:11: note: Following member(s) of "C" have conflicts:

main:11: note: x: expected "int", got "None"

-- Semanal errors in protocol types

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

[case testBasicSemanalErrorsInProtocols]

from typing import Protocol, Generic, TypeVar, Iterable

T = TypeVar('T', covariant=True)

S = TypeVar('S', covariant=True)

class P1(Protocol[T, T]): # E: Duplicate type variables in Generic[...] or Protocol[...]

def meth(self) -> T:

pass

class P2(Protocol[T], Protocol[S]): # E: Only single Generic[...] or Protocol[...] can be in bases

def meth(self) -> T:

pass

class P3(Protocol[T], Generic[S]): # E: Only single Generic[...] or Protocol[...] can be in bases

def meth(self) -> T:

pass

class P4(Protocol[T]):

attr: Iterable[S] # E: Invalid type "__main__.S"

class P5(Iterable[S], Protocol[T]): # E: If Generic[...] or Protocol[...] is present it should list all type variables

def meth(self) -> T:

pass

[case testProhibitSelfDefinitionInProtocols]

from typing import Protocol

class P(Protocol):

def __init__(self, a: int) -> None:

self.a = a # E: Protocol members cannot be defined via assignment to self \

# E: "P" has no attribute "a"

class B: pass

class C:

def __init__(self, a: int) -> None:

pass

x: P

x = B()

# The above has an incompatible __init__, but mypy ignores this for nominal subtypes?

x = C(1)

class P2(Protocol):

a: int

def __init__(self) -> None:

self.a = 1

class B2(P2):

a: int

x2: P2 = B2() # OK

[case testProtocolAndRuntimeAreDefinedAlsoInTypingExtensions]

from typing_extensions import Protocol, runtime

@runtime

class P(Protocol):

def meth(self) -> int:

pass

x: object

if isinstance(x, P):

reveal_type(x) # E: Revealed type is '__main__.P'

reveal_type(x.meth()) # E: Revealed type is 'builtins.int'

class C:

def meth(self) -> int:

pass

z: P = C()

[builtins fixtures/dict.pyi]

[case testProtocolsCannotInheritFromNormal]

from typing import Protocol

class C: pass

class D: pass

class P(C, Protocol): # E: All bases of a protocol must be protocols

attr: int

class P2(P, D, Protocol): # E: All bases of a protocol must be protocols

pass

P2() # E: Cannot instantiate abstract class 'P2' with abstract attribute 'attr'

p: P2

reveal_type(p.attr) # E: Revealed type is 'builtins.int'

-- Generic protocol types

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

[case testGenericMethodWithProtocol]

from typing import Protocol, TypeVar

T = TypeVar('T')

class P(Protocol):

def meth(self, x: int) -> int:

return x

class C:

def meth(self, x: T) -> T:

return x

x: P = C()

[case testGenericMethodWithProtocol2]

from typing import Protocol, TypeVar

T = TypeVar('T')

class P(Protocol):

def meth(self, x: T) -> T:

return x

class C:

def meth(self, x: int) -> int:

return x

x: P = C()

[out]

main:11: error: Incompatible types in assignment (expression has type "C", variable has type "P")

main:11: note: Following member(s) of "C" have conflicts:

main:11: note: Expected:

main:11: note: def [T] meth(self, x: T) -> T

main:11: note: Got:

main:11: note: def meth(self, x: int) -> int

[case testAutomaticProtocolVariance]

from typing import TypeVar, Protocol

T = TypeVar('T')

# In case of these errors we proceed with declared variance.

class Pco(Protocol[T]): # E: Invariant type variable 'T' used in protocol where covariant one is expected

def meth(self) -> T:

pass

class Pcontra(Protocol[T]): # E: Invariant type variable 'T' used in protocol where contravariant one is expected

def meth(self, x: T) -> None:

pass

class Pinv(Protocol[T]):

attr: T

class A: pass

class B(A): pass

x1: Pco[B]

y1: Pco[A]

if int():

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

if int():

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

x2: Pcontra[B]

y2: Pcontra[A]

if int():

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

if int():

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

x3: Pinv[B]

y3: Pinv[A]

if int():

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

if int():

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

[case testProtocolVarianceWithCallableAndList]

from typing import Protocol, TypeVar, Callable, List

T = TypeVar('T')

S = TypeVar('S')

T_co = TypeVar('T_co', covariant=True)

class P(Protocol[T, S]): # E: Invariant type variable 'T' used in protocol where covariant one is expected \

# E: Invariant type variable 'S' used in protocol where contravariant one is expected

def fun(self, callback: Callable[[T], S]) -> None: pass

class P2(Protocol[T_co]): # E: Covariant type variable 'T_co' used in protocol where invariant one is expected

lst: List[T_co]

[builtins fixtures/list.pyi]

[case testProtocolVarianceWithUnusedVariable]

from typing import Protocol, TypeVar

T = TypeVar('T')

class P(Protocol[T]): # E: Invariant type variable 'T' used in protocol where covariant one is expected

attr: int

[case testGenericProtocolsInference1]

from typing import Protocol, Sequence, TypeVar

T = TypeVar('T', covariant=True)

class Closeable(Protocol[T]):

def close(self) -> T:

pass

class F:

def close(self) -> int:

return 0

def close(arg: Closeable[T]) -> T:

return arg.close()

def close_all(args: Sequence[Closeable[T]]) -> T:

for arg in args:

arg.close()

return args[0].close()

arg: Closeable[int]

reveal_type(close(F())) # E: Revealed type is 'builtins.int*'

reveal_type(close(arg)) # E: Revealed type is 'builtins.int*'

reveal_type(close_all([F()])) # E: Revealed type is 'builtins.int*'

reveal_type(close_all([arg])) # E: Revealed type is 'builtins.int*'

[builtins fixtures/isinstancelist.pyi]

[typing fixtures/typing-full.pyi]

[case testProtocolGenericInference2]

from typing import Generic, TypeVar, Protocol

T = TypeVar('T')

S = TypeVar('S')

class P(Protocol[T, S]):

x: T

y: S

class C:

x: int

y: int

def fun3(x: P[T, T]) -> T:

pass

reveal_type(fun3(C())) # E: Revealed type is 'builtins.int*'

[case testProtocolGenericInferenceCovariant]

from typing import Generic, TypeVar, Protocol

T = TypeVar('T', covariant=True)

S = TypeVar('S', covariant=True)

U = TypeVar('U')

class P(Protocol[T, S]):

def x(self) -> T: pass

def y(self) -> S: pass

class C:

def x(self) -> int: pass

def y(self) -> int: pass

def fun4(x: U, y: P[U, U]) -> U:

pass

reveal_type(fun4('a', C())) # E: Revealed type is 'builtins.object*'

[case testUnrealtedGenericProtolsEquivalent]

from typing import TypeVar, Protocol

T = TypeVar('T')

class PA(Protocol[T]):

attr: int

def meth(self) -> T: pass

def other(self, arg: T) -> None: pass

class PB(Protocol[T]): # exactly the same as above

attr: int

def meth(self) -> T: pass

def other(self, arg: T) -> None: pass

def fun(x: PA[T]) -> PA[T]:

y: PB[T] = x

z: PB[T]

return z

x: PA

y: PB

x = y

y = x

xi: PA[int]

yi: PB[int]

xi = yi

yi = xi

[case testGenericSubProtocols]

from typing import TypeVar, Protocol, Tuple, Generic

T = TypeVar('T')

S = TypeVar('S')

class P1(Protocol[T]):

attr1: T

class P2(P1[T], Protocol[T, S]):

attr2: Tuple[T, S]

class C:

def __init__(self, a1: int, a2: Tuple[int, int]) -> None:

self.attr1 = a1

self.attr2 = a2

c: C

var: P2[int, int] = c

var2: P2[int, str] = c # E: Incompatible types in assignment (expression has type "C", variable has type "P2[int, str]") \

# N: Following member(s) of "C" have conflicts: \

# N: attr2: expected "Tuple[int, str]", got "Tuple[int, int]"

class D(Generic[T]):

attr1: T

class E(D[T]):

attr2: Tuple[T, T]

def f(x: T) -> T:

z: P2[T, T] = E[T]()

y: P2[T, T] = D[T]() # E: Incompatible types in assignment (expression has type "D[T]", variable has type "P2[T, T]") \

# N: 'D' is missing following 'P2' protocol member: \

# N: attr2

return x

[builtins fixtures/isinstancelist.pyi]

[case testGenericSubProtocolsExtensionInvariant]

from typing import TypeVar, Protocol, Union

T = TypeVar('T')

S = TypeVar('S')

class P1(Protocol[T]):

attr1: T

class P2(Protocol[T]):

attr2: T

class P(P1[T], P2[S], Protocol):

pass

class C:

attr1: int

attr2: str

class A:

attr1: A

class B:

attr2: B

class D(A, B): pass

x: P = D() # Same as P[Any, Any]

var: P[Union[int, P], Union[P, str]] = C() # E: Incompatible types in assignment (expression has type "C", variable has type "P[Union[int, P[Any, Any]], Union[P[Any, Any], str]]") \

# N: Following member(s) of "C" have conflicts: \

# N: attr1: expected "Union[int, P[Any, Any]]", got "int" \

# N: attr2: expected "Union[P[Any, Any], str]", got "str"

[case testGenericSubProtocolsExtensionCovariant]

from typing import TypeVar, Protocol, Union

T = TypeVar('T', covariant=True)

S = TypeVar('S', covariant=True)

class P1(Protocol[T]):

def attr1(self) -> T: pass

class P2(Protocol[T]):

def attr2(self) -> T: pass

class P(P1[T], P2[S], Protocol):

pass

class C:

def attr1(self) -> int: pass

def attr2(self) -> str: pass

var: P[Union[int, P], Union[P, str]] = C() # OK for covariant

var2: P[Union[str, P], Union[P, int]] = C()

[out]

main:18: error: Incompatible types in assignment (expression has type "C", variable has type "P[Union[str, P[Any, Any]], Union[P[Any, Any], int]]")

main:18: note: Following member(s) of "C" have conflicts:

main:18: note: Expected:

main:18: note: def attr1(self) -> Union[str, P[Any, Any]]

main:18: note: Got:

main:18: note: def attr1(self) -> int

main:18: note: Expected:

main:18: note: def attr2(self) -> Union[P[Any, Any], int]

main:18: note: Got:

main:18: note: def attr2(self) -> str

[case testSelfTypesWithProtocolsBehaveAsWithNominal]

from typing import Protocol, TypeVar

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

class Shape(Protocol):

def combine(self: T, other: T) -> T:

pass

class NonProtoShape:

def combine(self: T, other: T) -> T:

pass

class Circle:

def combine(self: T, other: Shape) -> T:

pass

class Triangle:

def combine(self, other: Shape) -> Shape:

pass

class Bad:

def combine(self, other: int) -> str:

pass

def f(s: Shape) -> None: pass

f(NonProtoShape())

f(Circle())

s: Shape

if int():

s = Triangle()

s = Bad()

n2: NonProtoShape = s

[out]

main:26: error: Incompatible types in assignment (expression has type "Triangle", variable has type "Shape")

main:26: note: Following member(s) of "Triangle" have conflicts:

main:26: note: Expected:

main:26: note: def combine(self, other: Triangle) -> Triangle

main:26: note: Got:

main:26: note: def combine(self, other: Shape) -> Shape

main:27: error: Incompatible types in assignment (expression has type "Bad", variable has type "Shape")

main:27: note: Following member(s) of "Bad" have conflicts:

main:27: note: Expected:

main:27: note: def combine(self, other: Bad) -> Bad

main:27: note: Got:

main:27: note: def combine(self, other: int) -> str

main:29: error: Incompatible types in assignment (expression has type "Shape", variable has type "NonProtoShape")

[case testBadVarianceInProtocols]

from typing import Protocol, TypeVar

T_co = TypeVar('T_co', covariant=True)

T_contra = TypeVar('T_contra', contravariant=True)

class Proto(Protocol[T_co, T_contra]): # type: ignore

def one(self, x: T_co) -> None: # E: Cannot use a covariant type variable as a parameter

pass

def other(self) -> T_contra: # E: Cannot use a contravariant type variable as return type

pass

# Check that we respect user overrides of variance after the errors are reported

x: Proto[int, float]

y: Proto[float, int]

y = x # OK

[builtins fixtures/list.pyi]

[case testSubtleBadVarianceInProtocols]

from typing import Protocol, TypeVar, Iterable, Sequence

T_co = TypeVar('T_co', covariant=True)

T_contra = TypeVar('T_contra', contravariant=True)

class Proto(Protocol[T_co, T_contra]): # E: Covariant type variable 'T_co' used in protocol where contravariant one is expected \

# E: Contravariant type variable 'T_contra' used in protocol where covariant one is expected

def one(self, x: Iterable[T_co]) -> None:

pass

def other(self) -> Sequence[T_contra]:

pass

# Check that we respect user overrides of variance after the errors are reported

x: Proto[int, float]

y: Proto[float, int]

y = x # OK

[builtins fixtures/list.pyi]

-- Recursive protocol types

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

[case testRecursiveProtocols1]

from typing import Protocol, Sequence, List, Generic, TypeVar

T = TypeVar('T')

class Traversable(Protocol):

@property

def leaves(self) -> Sequence[Traversable]: pass

class C: pass

class D(Generic[T]):

leaves: List[D[T]]

t: Traversable

t = D[int]() # OK

if int():

t = C() # E: Incompatible types in assignment (expression has type "C", variable has type "Traversable")

[builtins fixtures/list.pyi]

[typing fixtures/typing-full.pyi]

[case testRecursiveProtocols2]

from typing import Protocol, TypeVar

T = TypeVar('T')

class Linked(Protocol[T]):

val: T

def next(self) -> Linked[T]: pass

class L:

val: int

def next(self) -> L: pass

def last(seq: Linked[T]) -> T:

pass

reveal_type(last(L())) # E: Revealed type is 'builtins.int*'

[builtins fixtures/list.pyi]

[case testRecursiveProtocolSubtleMismatch]

from typing import Protocol, TypeVar

T = TypeVar('T')

class Linked(Protocol[T]):

val: T

def next(self) -> Linked[T]: pass

class L:

val: int

def next(self) -> int: pass

def last(seq: Linked[T]) -> T:

pass

last(L()) # E: Argument 1 to "last" has incompatible type "L"; expected "Linked[<nothing>]"

[case testMutuallyRecursiveProtocols]

from typing import Protocol, Sequence, List

class P1(Protocol):

@property

def attr1(self) -> Sequence[P2]: pass

class P2(Protocol):

@property

def attr2(self) -> Sequence[P1]: pass

class C: pass

class A:

attr1: List[B]

class B:

attr2: List[A]

t: P1

t = A() # OK

if int():

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

t = C() # E: Incompatible types in assignment (expression has type "C", variable has type "P1")

[builtins fixtures/list.pyi]

[typing fixtures/typing-full.pyi]

[case testMutuallyRecursiveProtocolsTypesWithSubteMismatch]

from typing import Protocol, Sequence, List

class P1(Protocol):

@property

def attr1(self) -> Sequence[P2]: pass

class P2(Protocol):

@property

def attr2(self) -> Sequence[P1]: pass

class C: pass

class A:

attr1: List[B]

class B:

attr2: List[C]

t: P1

t = A() # E: Incompatible types in assignment (expression has type "A", variable has type "P1") \

# N: Following member(s) of "A" have conflicts: \

# N: attr1: expected "Sequence[P2]", got "List[B]"

[builtins fixtures/list.pyi]

[case testMutuallyRecursiveProtocolsTypesWithSubteMismatchWriteable]

from typing import Protocol

class P1(Protocol):

@property

def attr1(self) -> P2: pass

class P2(Protocol):

attr2: P1

class A:

attr1: B

class B:

attr2: A

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

# N: Following member(s) of "A" have conflicts: \

# N: attr1: expected "P2", got "B"

[builtins fixtures/property.pyi]

-- FIXME: things like this should work

[case testWeirdRecursiveInferenceForProtocols-skip]

from typing import Protocol, TypeVar, Generic

T_co = TypeVar('T_co', covariant=True)

T = TypeVar('T')

class P(Protocol[T_co]):

def meth(self) -> P[T_co]: pass

class C(Generic[T]):

def meth(self) -> C[T]: pass

x: C[int]

def f(arg: P[T]) -> T: pass

reveal_type(f(x)) #E: Revealed type is 'builtins.int*'

-- @property, @classmethod and @staticmethod in protocol types

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

[case testCannotInstantiateAbstractMethodExplicitProtocolSubtypes]

from typing import Protocol

from abc import abstractmethod

class P(Protocol):

@abstractmethod

def meth(self) -> int:

pass

class A(P):

pass

A() # E: Cannot instantiate abstract class 'A' with abstract attribute 'meth'

class C(A):

def meth(self) -> int:

pass

class C2(P):

def meth(self) -> int:

pass

C()

C2()

[case testCannotInstantiateAbstractVariableExplicitProtocolSubtypes]

from typing import Protocol

class P(Protocol):

attr: int

class A(P):

pass

A() # E: Cannot instantiate abstract class 'A' with abstract attribute 'attr'

class C(A):

attr: int

class C2(P):

def __init__(self) -> None:

self.attr = 1

C()

C2()

class P2(Protocol):

attr: int = 1

class B(P2): pass

B() # OK, attr is not abstract

[case testClassVarsInProtocols]

from typing import Protocol, ClassVar

class PInst(Protocol):

v: int

class PClass(Protocol):

v: ClassVar[int]

class CInst:

v: int

class CClass:

v: ClassVar[int]

x: PInst

y: PClass

x = CInst()

if int():

x = CClass() # E: Incompatible types in assignment (expression has type "CClass", variable has type "PInst") \

# N: Protocol member PInst.v expected instance variable, got class variable

y = CClass()

if int():

y = CInst() # E: Incompatible types in assignment (expression has type "CInst", variable has type "PClass") \

# N: Protocol member PClass.v expected class variable, got instance variable

[case testPropertyInProtocols]

from typing import Protocol

class PP(Protocol):

@property

def attr(self) -> int:

pass

class P(Protocol):

attr: int

x: P

y: PP

y = x

x2: P

y2: PP

x2 = y2 # E: Incompatible types in assignment (expression has type "PP", variable has type "P") \

# N: Protocol member P.attr expected settable variable, got read-only attribute