[case testPEP695TypeAliasBasic]

type MyInt = int

def f(x: MyInt) -> MyInt:

return reveal_type(x) # N: Revealed type is "builtins.int"

type MyList[T] = list[T]

def g(x: MyList[int]) -> MyList[int]:

return reveal_type(x) # N: Revealed type is "builtins.list[builtins.int]"

type MyInt2 = int

def h(x: MyInt2) -> MyInt2:

return reveal_type(x) # N: Revealed type is "builtins.int"

[case testPEP695Class]

class MyGen[T]:

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

self.x = x

def f(x: MyGen[int]):

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

[case testPEP695Function]

def f[T](x: T) -> T:

return reveal_type(x) # N: Revealed type is "T`-1"

reveal_type(f(1)) # N: Revealed type is "builtins.int"

async def g[T](x: T) -> T:

return reveal_type(x) # N: Revealed type is "T`-1"

reveal_type(g(1)) # E: Value of type "Coroutine[Any, Any, int]" must be used \

# N: Are you missing an await? \

# N: Revealed type is "typing.Coroutine[Any, Any, builtins.int]"

[case testPEP695TypeVarBasic]

from typing import Callable

type Alias1[T: int] = list[T]

type Alias2[**P] = Callable[P, int]

type Alias3[*Ts] = tuple[*Ts]

class Cls1[T: int]: ...

class Cls2[**P]: ...

class Cls3[*Ts]: ...

def func1[T: int](x: T) -> T: ...

def func2[**P](x: Callable[P, int]) -> Callable[P, str]: ...

def func3[*Ts](x: tuple[*Ts]) -> tuple[int, *Ts]: ...

[builtins fixtures/tuple.pyi]

[case testPEP695TypeAliasType]

from typing import Callable, TypeAliasType, TypeVar, TypeVarTuple

T = TypeVar("T")

Ts = TypeVarTuple("Ts")

TestType = TypeAliasType("TestType", int | str)

x: TestType = 42

y: TestType = 'a'

z: TestType = object() # E: Incompatible types in assignment (expression has type "object", variable has type "int | str")

BadAlias1 = TypeAliasType("BadAlias1", tuple[*Ts]) # E: TypeVarTuple "Ts" is not included in type_params

ba1: BadAlias1[int] # E: Bad number of arguments for type alias, expected 0, given 1

reveal_type(ba1) # N: Revealed type is "builtins.tuple[Any, ...]"

BadAlias2 = TypeAliasType("BadAlias2", Callable[[*Ts], str]) # E: TypeVarTuple "Ts" is not included in type_params

ba2: BadAlias2[int] # E: Bad number of arguments for type alias, expected 0, given 1

reveal_type(ba2) # N: Revealed type is "def (*Any) -> builtins.str"

[builtins fixtures/tuple.pyi]

[typing fixtures/typing-full.pyi]

[case testPEP695IncompleteFeatureIsAcceptedButHasNoEffect]

# mypy: enable-incomplete-feature=NewGenericSyntax

def f[T](x: T) -> T:

return x

reveal_type(f(1)) # N: Revealed type is "builtins.int"

[case testPEP695GenericFunctionSyntax]

def ident[TV](x: TV) -> TV:

y: TV = x

y = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "TV")

return x

reveal_type(ident(1)) # N: Revealed type is "builtins.int"

reveal_type(ident('x')) # N: Revealed type is "builtins.str"

a: TV # E: Name "TV" is not defined

def tup[T, S](x: T, y: S) -> tuple[T, S]:

reveal_type((x, y)) # N: Revealed type is "tuple[T`-1, S`-2]"

return (x, y)

reveal_type(tup(1, 'x')) # N: Revealed type is "tuple[builtins.int, builtins.str]"

[builtins fixtures/tuple.pyi]

[case testPEP695GenericClassSyntax]

class C[T]:

x: T

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

self.x = x

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

y: T = x

if int():

return self.x

else:

return y

reveal_type(C("x")) # N: Revealed type is "__main__.C[builtins.str]"

c: C[int] = C(1)

reveal_type(c.x) # N: Revealed type is "builtins.int"

reveal_type(c.ident(1)) # N: Revealed type is "builtins.int"

[case testPEP695GenericMethodInGenericClass]

class C[T]:

def m[S](self, x: S) -> T | S: ...

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

b: C[object] = C[int]()

reveal_type(C[str]().m(1)) # N: Revealed type is "builtins.str | builtins.int"

[case testPEP695InferVarianceSimpleFromMethod]

class Invariant[T]:

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

pass

def g(self) -> T | None:

return None

a: Invariant[object]

b: Invariant[int]

if int():

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

if int():

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

class Covariant[T]:

def g(self) -> T | None:

return None

c: Covariant[object]

d: Covariant[int]

if int():

c = d

if int():

d = c # E: Incompatible types in assignment (expression has type "Covariant[object]", variable has type "Covariant[int]")

class Contravariant[T]:

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

pass

e: Contravariant[object]

f: Contravariant[int]

if int():

e = f # E: Incompatible types in assignment (expression has type "Contravariant[int]", variable has type "Contravariant[object]")

if int():

f = e

[case testPEP695InferVarianceSimpleFromAttribute]

class Invariant1[T]:

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

self.x = x

a: Invariant1[object]

b: Invariant1[int]

if int():

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

if int():

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

class Invariant2[T]:

def __init__(self) -> None:

self.x: list[T] = []

a2: Invariant2[object]

b2: Invariant2[int]

if int():

a2 = b2 # E: Incompatible types in assignment (expression has type "Invariant2[int]", variable has type "Invariant2[object]")

if int():

b2 = a2 # E: Incompatible types in assignment (expression has type "Invariant2[object]", variable has type "Invariant2[int]")

class Invariant3[T]:

def __init__(self) -> None:

self.x: T | None = None

a3: Invariant3[object]

b3: Invariant3[int]

if int():

a3 = b3 # E: Incompatible types in assignment (expression has type "Invariant3[int]", variable has type "Invariant3[object]")

if int():

b3 = a3 # E: Incompatible types in assignment (expression has type "Invariant3[object]", variable has type "Invariant3[int]")

[case testPEP695InferVarianceRecursive]

class Invariant[T]:

def f(self, x: Invariant[T]) -> Invariant[T]:

return x

class Covariant[T]:

def f(self) -> Covariant[T]:

return self

class Contravariant[T]:

def f(self, x: Contravariant[T]) -> None:

pass

a: Invariant[object]

b: Invariant[int]

if int():

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

if int():

b = a

c: Covariant[object]

d: Covariant[int]

if int():

c = d

if int():

d = c # E: Incompatible types in assignment (expression has type "Covariant[object]", variable has type "Covariant[int]")

e: Contravariant[object]

f: Contravariant[int]

if int():

e = f # E: Incompatible types in assignment (expression has type "Contravariant[int]", variable has type "Contravariant[object]")

if int():

f = e

[case testPEP695InferVarianceInFrozenDataclass]

from dataclasses import dataclass

@dataclass(frozen=True)

class Covariant[T]:

x: T

cov1: Covariant[float] = Covariant[int](1)

cov2: Covariant[int] = Covariant[float](1) # E: Incompatible types in assignment (expression has type "Covariant[float]", variable has type "Covariant[int]")

@dataclass(frozen=True)

class Invariant[T]:

x: list[T]

inv1: Invariant[float] = Invariant[int]([1]) # E: Incompatible types in assignment (expression has type "Invariant[int]", variable has type "Invariant[float]")

inv2: Invariant[int] = Invariant[float]([1]) # E: Incompatible types in assignment (expression has type "Invariant[float]", variable has type "Invariant[int]")

[builtins fixtures/tuple.pyi]

[typing fixtures/typing-full.pyi]

[case testPEP695InferVarianceCalculateOnDemand]

class Covariant[T]:

def __init__(self) -> None:

self.x = [1]

def f(self) -> None:

c = Covariant[int]()

# We need to know that T is covariant here

self.g(c)

c2 = Covariant[object]()

self.h(c2) # E: Argument 1 to "h" of "Covariant" has incompatible type "Covariant[object]"; expected "Covariant[int]"

def g(self, x: Covariant[object]) -> None: pass

def h(self, x: Covariant[int]) -> None: pass

[case testPEP695InferVarianceNotReadyWhenNeeded]

class Covariant[T]:

def f(self) -> None:

c = Covariant[int]()

# We need to know that T is covariant here

self.g(c)

c2 = Covariant[object]()

self.h(c2) # E: Argument 1 to "h" of "Covariant" has incompatible type "Covariant[object]"; expected "Covariant[int]"

def g(self, x: Covariant[object]) -> None: pass

def h(self, x: Covariant[int]) -> None: pass

def __init__(self) -> None:

self.x = [1]

class Invariant[T]:

def f(self) -> None:

# We add this to force processing this method as part of the interface in parallel checking,

# otherwise, it will be processed at a later stage, not testing the no ready behavior below

self.y = int()

c = Invariant(1)

# We need to know that T is invariant here, and for this we need the type

# of self.x, which won't be available on the first type checking pass,

# since __init__ is defined later in the file. In this case we fall back

# covariance.

self.g(c)

c2 = Invariant(object())

self.h(c2) # E: Argument 1 to "h" of "Invariant" has incompatible type "Invariant[object]"; expected "Invariant[int]"

def g(self, x: Invariant[object]) -> None: pass

def h(self, x: Invariant[int]) -> None: pass

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

self.x = x

# Now we should have the variance correct.

a: Invariant[object]

b: Invariant[int]

if int():

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

if int():

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

[case testPEP695InferVarianceNotReadyForJoin]

class Invariant[T]:

def f(self) -> None:

self.y = int()

# Assume covariance if variance us not ready

reveal_type([Invariant(1), Invariant(object())]) \

# N: Revealed type is "builtins.list[__main__.Invariant[builtins.object]]"

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

self.x = x

reveal_type([Invariant(1), Invariant(object())]) # N: Revealed type is "builtins.list[builtins.object]"

[case testPEP695InferVarianceNotReadyForMeet]

from typing import TypeVar, Callable

S = TypeVar("S")

def c(a: Callable[[S], None], b: Callable[[S], None]) -> S: ...

def a1(x: Invariant[int]) -> None: pass

def a2(x: Invariant[object]) -> None: pass

class Invariant[T]:

def f(self) -> None:

self.y = int()

reveal_type(c(a1, a2)) # N: Revealed type is "__main__.Invariant[builtins.int]"

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

self.x = x

reveal_type(c(a1, a2)) # N: Revealed type is "Never"

[case testPEP695InferVarianceUnderscorePrefix]

class Covariant1[T]:

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

self._x = x

@property

def x(self) -> T:

return self._x

co1_1: Covariant1[float] = Covariant1[int](1)

co1_2: Covariant1[int] = Covariant1[float](1) # E: Incompatible types in assignment (expression has type "Covariant1[float]", variable has type "Covariant1[int]")

class Covariant2[T]:

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

self.__foo_bar = x

@property

def x(self) -> T:

return self.__foo_bar

co2_1: Covariant2[float] = Covariant2[int](1)

co2_2: Covariant2[int] = Covariant2[float](1) # E: Incompatible types in assignment (expression has type "Covariant2[float]", variable has type "Covariant2[int]")

class Invariant1[T]:

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

self._x = x

# Methods behave differently from attributes

def _f(self, x: T) -> None: ...

@property

def x(self) -> T:

return self._x

inv1_1: Invariant1[float] = Invariant1[int](1) # E: Incompatible types in assignment (expression has type "Invariant1[int]", variable has type "Invariant1[float]")

inv1_2: Invariant1[int] = Invariant1[float](1) # E: Incompatible types in assignment (expression has type "Invariant1[float]", variable has type "Invariant1[int]")

class Invariant2[T]:

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

# Dunders are special

self.__x__ = x

@property

def x(self) -> T:

return self.__x__

inv2_1: Invariant2[float] = Invariant2[int](1) # E: Incompatible types in assignment (expression has type "Invariant2[int]", variable has type "Invariant2[float]")

inv2_2: Invariant2[int] = Invariant2[float](1) # E: Incompatible types in assignment (expression has type "Invariant2[float]", variable has type "Invariant2[int]")

class Invariant3[T]:

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

self._x = Invariant1(x)

@property

def x(self) -> T:

return self._x._x

inv3_1: Invariant3[float] = Invariant3[int](1) # E: Incompatible types in assignment (expression has type "Invariant3[int]", variable has type "Invariant3[float]")

inv3_2: Invariant3[int] = Invariant3[float](1) # E: Incompatible types in assignment (expression has type "Invariant3[float]", variable has type "Invariant3[int]")

[builtins fixtures/property.pyi]

[case testPEP695InferVarianceWithInheritedSelf]

from typing import overload, Self, TypeVar, Generic

T = TypeVar("T")

S = TypeVar("S")

class C(Generic[T]):

def f(self, x: T) -> Self: ...

def g(self) -> T: ...

class D[T1, T2](C[T1]):

def m(self, x: T2) -> None: ...

a1: D[int, int] = D[int, object]()

a2: D[int, object] = D[int, int]() # E: Incompatible types in assignment (expression has type "D[int, int]", variable has type "D[int, object]")

a3: D[int, int] = D[object, object]() # E: Incompatible types in assignment (expression has type "D[object, object]", variable has type "D[int, int]")

a4: D[object, int] = D[int, object]() # E: Incompatible types in assignment (expression has type "D[int, object]", variable has type "D[object, int]")

[case testPEP695InferVarianceWithReturnSelf]

from typing import Self, overload

class Cov[T]:

def f(self) -> Self: ...

a1: Cov[int] = Cov[float]() # E: Incompatible types in assignment (expression has type "Cov[float]", variable has type "Cov[int]")

a2: Cov[float] = Cov[int]()

class Contra[T]:

def f(self) -> Self: ...

def g(self, x: T) -> None: ...

b1: Contra[int] = Contra[float]()

b2: Contra[float] = Contra[int]() # E: Incompatible types in assignment (expression has type "Contra[int]", variable has type "Contra[float]")

class Cov2[T]:

@overload

def f(self, x): ...

@overload

def f(self) -> Self: ...

def f(self, x=None): ...

c1: Cov2[int] = Cov2[float]() # E: Incompatible types in assignment (expression has type "Cov2[float]", variable has type "Cov2[int]")

c2: Cov2[float] = Cov2[int]()

class Contra2[T]:

@overload

def f(self, x): ...

@overload

def f(self) -> Self: ...

def f(self, x=None): ...

def g(self, x: T) -> None: ...

d1: Contra2[int] = Contra2[float]()

d2: Contra2[float] = Contra2[int]() # E: Incompatible types in assignment (expression has type "Contra2[int]", variable has type "Contra2[float]")

[case testPEP695InheritInvariant]

class Invariant[T]:

x: T

class Subclass[T](Invariant[T]):

pass

x: Invariant[int]

y: Invariant[object]

if int():

x = y # E: Incompatible types in assignment (expression has type "Invariant[object]", variable has type "Invariant[int]")

if int():

y = x # E: Incompatible types in assignment (expression has type "Invariant[int]", variable has type "Invariant[object]")

a: Subclass[int]

b: Subclass[object]

if int():

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

if int():

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

[case testPEP695InheritanceMakesInvariant]

class Covariant[T]:

def f(self) -> T:

...

class Subclass[T](Covariant[list[T]]):

pass

x: Covariant[int] = Covariant[object]() # E: Incompatible types in assignment (expression has type "Covariant[object]", variable has type "Covariant[int]")

y: Covariant[object] = Covariant[int]()

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

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

[case testPEP695InheritCoOrContravariant]

class Contravariant[T]:

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

class CovSubclass[T](Contravariant[T]):

pass

a: CovSubclass[int] = CovSubclass[object]()

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

class Covariant[T]:

def f(self) -> T: ...

class CoSubclass[T](Covariant[T]):

pass

c: CoSubclass[int] = CoSubclass[object]() # E: Incompatible types in assignment (expression has type "CoSubclass[object]", variable has type "CoSubclass[int]")

d: CoSubclass[object] = CoSubclass[int]()

class InvSubclass[T](Covariant[T]):

def g(self, x: T) -> None: pass

e: InvSubclass[int] = InvSubclass[object]() # E: Incompatible types in assignment (expression has type "InvSubclass[object]", variable has type "InvSubclass[int]")

f: InvSubclass[object] = InvSubclass[int]() # E: Incompatible types in assignment (expression has type "InvSubclass[int]", variable has type "InvSubclass[object]")

[case testPEP695FinalAttribute]

from typing import Final

class C[T]:

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

self.x: Final = x

a: C[int] = C[object](1) # E: Incompatible types in assignment (expression has type "C[object]", variable has type "C[int]")

b: C[object] = C[int](1)

[case testPEP695TwoTypeVariables]

class C[T, S]:

def f(self, x: T) -> None: ...

def g(self) -> S: ...

a: C[int, int] = C[object, int]()

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

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

d: C[int, object] = C[int, int]()

[case testPEP695Properties]

class R[T]:

@property

def p(self) -> T: ...

class RW[T]:

@property

def p(self) -> T: ...

@p.setter

def p(self, x: T) -> None: ...

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

b: R[object] = R[int]()

c: RW[int] = RW[object]() # E: Incompatible types in assignment (expression has type "RW[object]", variable has type "RW[int]")

d: RW[object] = RW[int]() # E: Incompatible types in assignment (expression has type "RW[int]", variable has type "RW[object]")

[builtins fixtures/property.pyi]

[case testPEP695Protocol]

from typing import Protocol

class PContra[T](Protocol):

def f(self, x: T) -> None: ...

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

a: PContra[int]

b: PContra[object]

if int():

a = b

if int():

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

class PCov[T](Protocol):

def f(self) -> T: ...

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

c: PCov[int]

d: PCov[object]

if int():

c = d # E: Incompatible types in assignment (expression has type "PCov[object]", variable has type "PCov[int]")

if int():

d = c

class PInv[T](Protocol):

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

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

e: PInv[int]

f: PInv[object]

if int():

e = f # E: Incompatible types in assignment (expression has type "PInv[object]", variable has type "PInv[int]")

if int():

f = e # E: Incompatible types in assignment (expression has type "PInv[int]", variable has type "PInv[object]")

[case testPEP695TypeAlias]

class C[T]: pass

class D[T, S]: pass

type A[S] = C[S]

a: A[int]

reveal_type(a) # N: Revealed type is "__main__.C[builtins.int]"

type A2[T] = C[C[T]]

a2: A2[str]

reveal_type(a2) # N: Revealed type is "__main__.C[__main__.C[builtins.str]]"

type A3[T, S] = D[S, C[T]]

a3: A3[int, str]

reveal_type(a3) # N: Revealed type is "__main__.D[builtins.str, __main__.C[builtins.int]]"

type A4 = int | str

a4: A4

reveal_type(a4) # N: Revealed type is "builtins.int | builtins.str"

[builtins fixtures/type.pyi]

[case testPEP695TypeAliasNotValidAsBaseClass]

from typing import TypeAlias

import m

type A1 = int

class Bad1(A1): # E: Type alias defined using "type" statement not valid as base class

pass

type A2[T] = list[T]

class Bad2(A2[int]): # E: Type alias defined using "type" statement not valid as base class

pass

class Bad3(m.A1): # E: Type alias defined using "type" statement not valid as base class

pass

class Bad4(m.A2[int]): # E: Type alias defined using "type" statement not valid as base class

pass

B1 = int

B2 = list

B3: TypeAlias = int

class Good1(B1): pass

class Good2(B2[int]): pass

class Good3(list[A1]): pass

class Good4(list[A2[int]]): pass

class Good5(B3): pass

[file m.py]

type A1 = str

type A2[T] = list[T]

[typing fixtures/typing-medium.pyi]

[case testPEP695TypeAliasWithUnusedTypeParams]

type A[T] = int

a: A[str]

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

[case testPEP695TypeAliasForwardReference1]

type A[T] = C[T]

a: A[int]

reveal_type(a) # N: Revealed type is "__main__.C[builtins.int]"

class C[T]: pass

[case testPEP695TypeAliasForwardReference2]

type X = C

type A = X

a: A

reveal_type(a) # N: Revealed type is "__main__.C"

class C: pass

[builtins fixtures/tuple.pyi]

[typing fixtures/typing-full.pyi]

[case testPEP695TypeAliasForwardReference3]

type X = D

type A = C[X]

a: A

reveal_type(a) # N: Revealed type is "__main__.C[__main__.D]"

class C[T]: pass

class D: pass

[case testPEP695TypeAliasForwardReference4]

type A = C

class D(A): # E: Type alias defined using "type" statement not valid as base class

pass

class C: pass

x: C = D()

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

[case testPEP695TypeAliasForwardReference5]

type A = str

type B[T] = C[T]

class C[T]: pass

a: A

b: B[int]

c: C[str]

reveal_type(a) # N: Revealed type is "builtins.str"

reveal_type(b) # N: Revealed type is "__main__.C[builtins.int]"

reveal_type(c) # N: Revealed type is "__main__.C[builtins.str]"

[case testPEP695TypeAliasWithUndefineName]

type A[T] = XXX # E: Name "XXX" is not defined

a: A[int]

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

[case testPEP695TypeAliasInvalidType]

type A = int | 1 # E: Invalid type: try using Literal[1] instead?

a: A

reveal_type(a) # N: Revealed type is "builtins.int | Any"

type B = int + str # E: Invalid type alias: expression is not a valid type

b: B

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

[builtins fixtures/type.pyi]

[case testPEP695TypeAliasBoundForwardReference]

type B[T: Foo] = list[T]

class Foo: pass

[case testPEP695UpperBound]

class D:

x: int

class E(D): pass

class C[T: D]: pass

a: C[D]

b: C[E]

reveal_type(a) # N: Revealed type is "__main__.C[__main__.D]"

reveal_type(b) # N: Revealed type is "__main__.C[__main__.E]"

c: C[int] # E: Type argument "int" of "C" must be a subtype of "D"

def f[T: D](a: T) -> T:

reveal_type(a.x) # N: Revealed type is "builtins.int"

return a

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

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

f(1) # E: Value of type variable "T" of "f" cannot be "int"

[case testPEP695UpperBoundForwardReference1]

class C[T: D]: pass

a: C[D]

b: C[E]

reveal_type(a) # N: Revealed type is "__main__.C[__main__.D]"

reveal_type(b) # N: Revealed type is "__main__.C[__main__.E]"

c: C[int] # E: Type argument "int" of "C" must be a subtype of "D"

class D: pass

class E(D): pass

[case testPEP695UpperBoundForwardReference2]

type A = D

class C[T: A]: pass

class D: pass

class E(D): pass

a: C[D]

b: C[E]

reveal_type(a) # N: Revealed type is "__main__.C[__main__.D]"

reveal_type(b) # N: Revealed type is "__main__.C[__main__.E]"

c: C[int] # E: Type argument "int" of "C" must be a subtype of "D"

[case testPEP695UpperBoundForwardReference3]

class D[T]: pass

class E[T](D[T]): pass

type A = D[X]

class C[T: A]: pass

class X: pass

a: C[D[X]]

b: C[E[X]]

reveal_type(a) # N: Revealed type is "__main__.C[__main__.D[__main__.X]]"

reveal_type(b) # N: Revealed type is "__main__.C[__main__.E[__main__.X]]"

c: C[D[int]] # E: Type argument "D[int]" of "C" must be a subtype of "D[X]"

[case testPEP695UpperBoundForwardReference4]

def f[T: D](a: T) -> T:

reveal_type(a.x) # N: Revealed type is "builtins.int"

return a

class D:

x: int

class E(D): pass

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

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

f(1) # E: Value of type variable "T" of "f" cannot be "int"

[case testPEP695UpperBoundUndefinedName]

class C[T: XX]: # E: Name "XX" is not defined

pass

a: C[int]

def f[T: YY](x: T) -> T: # E: Name "YY" is not defined

return x

reveal_type(f) # N: Revealed type is "def [T <: Any] (x: T`-1) -> T`-1"

[case testPEP695UpperBoundWithMultipleParams]

class C[T, S: int]: pass

class D[A: int, B]: pass

def f[T: int, S: int | str](x: T, y: S) -> T | S:

return x

C[str, int]()

C[str, str]() # E: Value of type variable "S" of "C" cannot be "str"

D[int, str]()

D[str, str]() # E: Value of type variable "A" of "D" cannot be "str"

f(1, 1)

u: int | str

f(1, u)

f('x', None) # E: Value of type variable "T" of "f" cannot be "str" \

# E: Value of type variable "S" of "f" cannot be "None"

[case testPEP695InferVarianceOfTupleType]

class Cov[T](tuple[int, str]):

def f(self) -> T: pass

class Cov2[T](tuple[T, T]):

pass

class Contra[T](tuple[int, str]):

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

a: Cov[object] = Cov[int]()

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

c: Cov2[object] = Cov2[int]()

d: Cov2[int] = Cov2[object]() # E: Incompatible types in assignment (expression has type "Cov2[object]", variable has type "Cov2[int]")

e: Contra[int] = Contra[object]()

f: Contra[object] = Contra[int]() # E: Incompatible types in assignment (expression has type "Contra[int]", variable has type "Contra[object]")

[builtins fixtures/tuple-simple.pyi]

[case testPEP695ValueRestriction]

def f[T: (int, str)](x: T) -> T:

reveal_type(x) # N: Revealed type is "builtins.int" \

# N: Revealed type is "builtins.str"

return x

reveal_type(f(1)) # N: Revealed type is "builtins.int"

reveal_type(f('x')) # N: Revealed type is "builtins.str"

f(None) # E: Value of type variable "T" of "f" cannot be "None"

class C[T: (object, None)]: pass

a: C[object]

b: C[None]

c: C[int] # E: Value of type variable "T" of "C" cannot be "int"

[case testPEP695ValueRestrictionForwardReference]

class C[T: (int, D)]:

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

a = x

if int():

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

# E: Incompatible types in assignment (expression has type "str", variable has type "D")

self.x: T = x

reveal_type(C(1).x) # N: Revealed type is "builtins.int"

C(None) # E: Value of type variable "T" of "C" cannot be "None"

class D: pass

C(D())

[case testPEP695ValueRestrictionUndefinedName]

class C[T: (int, XX)]: # E: Name "XX" is not defined

pass

def f[S: (int, YY)](x: S) -> S: # E: Name "YY" is not defined

return x

[case testPEP695ParamSpec]

from typing import Callable

def g[**P](f: Callable[P, None], *args: P.args, **kwargs: P.kwargs) -> None:

f(*args, **kwargs)

f(1, *args, **kwargs) # E: Argument 1 has incompatible type "int"; expected "P.args"

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

g(h, 1, y='x')

g(h, 1, x=1) # E: "g" gets multiple values for keyword argument "x" \

# E: Missing positional argument "y" in call to "g"

class C[**P, T]:

def m(self, *args: P.args, **kwargs: P.kwargs) -> T: ...

a: C[[int, str], None]

reveal_type(a) # N: Revealed type is "__main__.C[[builtins.int, builtins.str], None]"

reveal_type(a.m) # N: Revealed type is "def (builtins.int, builtins.str)"

[builtins fixtures/tuple.pyi]

[case testPEP695ParamSpecTypeAlias]

from typing import Callable

type C[**P] = Callable[P, int]

f: C[[str, int | None]]

reveal_type(f) # N: Revealed type is "def (builtins.str, builtins.int | None) -> builtins.int"

[builtins fixtures/tuple.pyi]

[typing fixtures/typing-full.pyi]

[case testPEP695TypeVarTuple]

def f[*Ts](t: tuple[*Ts]) -> tuple[*Ts]:

reveal_type(t) # N: Revealed type is "tuple[Unpack[Ts`-1]]"

return t

reveal_type(f((1, 'x'))) # N: Revealed type is "tuple[Literal[1]?, Literal['x']?]"

a: tuple[int, ...]

reveal_type(f(a)) # N: Revealed type is "builtins.tuple[builtins.int, ...]"

class C[T, *Ts]:

pass

b: C[int, str, None]

reveal_type(b) # N: Revealed type is "__main__.C[builtins.int, builtins.str, None]"

c: C[str]

reveal_type(c) # N: Revealed type is "__main__.C[builtins.str]"

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

[builtins fixtures/tuple.pyi]

[case testPEP695TypeVarTupleAlias]

from typing import Callable

type C[*Ts] = tuple[*Ts, int]

a: C[str, None]

reveal_type(a) # N: Revealed type is "tuple[builtins.str, None, builtins.int]"

[builtins fixtures/tuple.pyi]

[case testPEP695IncrementalFunction]

import a

[file a.py]

import b

[file a.py.2]

import b

reveal_type(b.f(1))

reveal_type(b.g(1, 'x'))

b.g('x', 'x')

b.g(1, 2)

[file b.py]

def f[T](x: T) -> T:

return x

def g[T: int, S: (str, None)](x: T, y: S) -> T | S:

return x

[out2]

tmp/a.py:2: note: Revealed type is "builtins.int"

tmp/a.py:3: note: Revealed type is "builtins.int | builtins.str"

tmp/a.py:4: error: Value of type variable "T" of "g" cannot be "str"

tmp/a.py:5: error: Value of type variable "S" of "g" cannot be "int"

[case testPEP695IncrementalClass]

import a

[file a.py]

import b

[file a.py.2]

from b import C, D

x: C[int]

reveal_type(x)

class N(int): pass

class SS(str): pass

y1: D[int, str]

y2: D[N, str]

y3: D[int, None]

y4: D[int, None]

y5: D[int, SS] # Error

y6: D[object, str] # Error

[file b.py]

class C[T]: pass

class D[T: int, S: (str, None)]:

pass

[out2]

tmp/a.py:3: note: Revealed type is "b.C[builtins.int]"

tmp/a.py:12: error: Value of type variable "S" of "D" cannot be "SS"