[case testVarWithType]
import typing
class A: pass
x = A() # type: A
y = x
[out]
MypyFile:1(
  Import:1(typing)
  ClassDef:2(
    A
    PassStmt:2())
  AssignmentStmt:3(
    NameExpr(x [__main__.x])
    CallExpr:3(
      NameExpr(A [__main__.A])
      Args())
    __main__.A)
  AssignmentStmt:4(
    NameExpr(y* [__main__.y])
    NameExpr(x [__main__.x])))

[case testLocalVarWithType]
class A: pass
def f():
  x = None # type: A
  y = x
[out]
MypyFile:1(
  ClassDef:1(
    A
    PassStmt:1())
  FuncDef:2(
    f
    Block:2(
      AssignmentStmt:3(
        NameExpr(x [l])
        NameExpr(None [builtins.None])
        __main__.A)
      AssignmentStmt:4(
        NameExpr(y* [l])
        NameExpr(x [l])))))

[case testAnyType]
from typing import Any
x = None # type: Any
y = x
[out]
MypyFile:1(
  ImportFrom:1(typing, [Any])
  AssignmentStmt:2(
    NameExpr(x [__main__.x])
    NameExpr(None [builtins.None])
    Any)
  AssignmentStmt:3(
    NameExpr(y* [__main__.y])
    NameExpr(x [__main__.x])))

[case testMemberVarWithType]
import typing
class A:
  def __init__(self):
    self.x = None # type: int
[out]
MypyFile:1(
  Import:1(typing)
  ClassDef:2(
    A
    FuncDef:3(
      __init__
      Args(
        Var(self))
      Block:3(
        AssignmentStmt:4(
          MemberExpr:4(
            NameExpr(self [l])
            x)
          NameExpr(None [builtins.None])
          builtins.int)))))

[case testClassVarWithType]
import typing
class A:
  x = None # type: int
  x = 1
[out]
MypyFile:1(
  Import:1(typing)
  ClassDef:2(
    A
    AssignmentStmt:3(
      NameExpr(x [m])
      NameExpr(None [builtins.None])
      builtins.int)
    AssignmentStmt:4(
      NameExpr(x [__main__.A.x])
      IntExpr(1))))

[case testFunctionSig]
from typing import Any
class A: pass
def f(x: A) -> A: pass
def g(x: Any, y: A) -> None:
  z = x, y
[out]
MypyFile:1(
  ImportFrom:1(typing, [Any])
  ClassDef:2(
    A
    PassStmt:2())
  FuncDef:3(
    f
    Args(
      Var(x))
    def (x: __main__.A) -> __main__.A
    Block:3(
      PassStmt:3()))
  FuncDef:4(
    g
    Args(
      Var(x)
      Var(y))
    def (x: Any, y: __main__.A)
    Block:4(
      AssignmentStmt:5(
        NameExpr(z* [l])
        TupleExpr:5(
          NameExpr(x [l])
          NameExpr(y [l]))))))

[case testBaseclass]
class A: pass
class B(A): pass
[out]
MypyFile:1(
  ClassDef:1(
    A
    PassStmt:1())
  ClassDef:2(
    B
    BaseType(
      __main__.A)
    PassStmt:2()))

[case testMultipleVarDef]

class A: pass
class B: pass
a, b = None, None # type: (A, B)
x = a, b
[out]
MypyFile:1(
  ClassDef:2(
    A
    PassStmt:2())
  ClassDef:3(
    B
    PassStmt:3())
  AssignmentStmt:4(
    TupleExpr:4(
      NameExpr(a [__main__.a])
      NameExpr(b [__main__.b]))
    TupleExpr:4(
      NameExpr(None [builtins.None])
      NameExpr(None [builtins.None]))
    Tuple[__main__.A, __main__.B])
  AssignmentStmt:5(
    NameExpr(x* [__main__.x])
    TupleExpr:5(
      NameExpr(a [__main__.a])
      NameExpr(b [__main__.b]))))

[case testGenericType]
from typing import TypeVar, Generic, Any

t = TypeVar('t')

class A(Generic[t]): pass
class B: pass
x = None # type: A[B]
y = None # type: A[Any]
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar, Generic, Any])
  AssignmentStmt:3(
    NameExpr(t* [__main__.t])
    TypeVarExpr:3())
  ClassDef:5(
    A
    TypeVars(
      t)
    PassStmt:5())
  ClassDef:6(
    B
    PassStmt:6())
  AssignmentStmt:7(
    NameExpr(x [__main__.x])
    NameExpr(None [builtins.None])
    __main__.A[__main__.B])
  AssignmentStmt:8(
    NameExpr(y [__main__.y])
    NameExpr(None [builtins.None])
    __main__.A[Any]))

[case testGenericType2]
from typing import TypeVar, Generic, Any
t = TypeVar('t')
s = TypeVar('s')
class A(Generic[t, s]): pass
class B: pass
x = None # type: A[B, Any]
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar, Generic, Any])
  AssignmentStmt:2(
    NameExpr(t* [__main__.t])
    TypeVarExpr:2())
  AssignmentStmt:3(
    NameExpr(s* [__main__.s])
    TypeVarExpr:3())
  ClassDef:4(
    A
    TypeVars(
      t
      s)
    PassStmt:4())
  ClassDef:5(
    B
    PassStmt:5())
  AssignmentStmt:6(
    NameExpr(x [__main__.x])
    NameExpr(None [builtins.None])
    __main__.A[__main__.B, Any]))

[case testAssignmentAfterDef]


class A: pass
a = None # type: A
a = 1
def f():
  b = None # type: A
  b = 1
[out]
MypyFile:1(
  ClassDef:3(
    A
    PassStmt:3())
  AssignmentStmt:4(
    NameExpr(a [__main__.a])
    NameExpr(None [builtins.None])
    __main__.A)
  AssignmentStmt:5(
    NameExpr(a [__main__.a])
    IntExpr(1))
  FuncDef:6(
    f
    Block:6(
      AssignmentStmt:7(
        NameExpr(b [l])
        NameExpr(None [builtins.None])
        __main__.A)
      AssignmentStmt:8(
        NameExpr(b [l])
        IntExpr(1)))))

[case testCast]
from typing import TypeVar, Generic, Any, cast
t = TypeVar('t')
class c: pass
class d(Generic[t]): pass
cast(Any, 1)
cast(c, 1)
cast(d[c], c)
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar, Generic, Any, cast])
  AssignmentStmt:2(
    NameExpr(t* [__main__.t])
    TypeVarExpr:2())
  ClassDef:3(
    c
    PassStmt:3())
  ClassDef:4(
    d
    TypeVars(
      t)
    PassStmt:4())
  ExpressionStmt:5(
    CastExpr:5(
      IntExpr(1)
      Any))
  ExpressionStmt:6(
    CastExpr:6(
      IntExpr(1)
      __main__.c))
  ExpressionStmt:7(
    CastExpr:7(
      NameExpr(c [__main__.c])
      __main__.d[__main__.c])))

[case testCastToQualifiedTypeAndCast]
import typing
import _m
typing.cast(_m.C, object)
[file _m.py]
class C: pass
[out]
MypyFile:1(
  Import:1(typing)
  Import:2(_m)
  ExpressionStmt:3(
    CastExpr:3(
      NameExpr(object [builtins.object])
      _m.C)))

[case testLongQualifiedCast]
import typing
import _m._n
typing.cast(_m._n.C, object)
[file _m/__init__.py]
[file _m/_n.py]
class C: pass
[out]
MypyFile:1(
  Import:1(typing)
  Import:2(_m._n)
  ExpressionStmt:3(
    CastExpr:3(
      NameExpr(object [builtins.object])
      _m._n.C)))

[case testCastTargetWithTwoTypeArgs]
from typing import TypeVar, Generic, cast
t = TypeVar('t')
s = TypeVar('s')
class C(Generic[t, s]): pass
cast(C[str, int], C)
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar, Generic, cast])
  AssignmentStmt:2(
    NameExpr(t* [__main__.t])
    TypeVarExpr:2())
  AssignmentStmt:3(
    NameExpr(s* [__main__.s])
    TypeVarExpr:3())
  ClassDef:4(
    C
    TypeVars(
      t
      s)
    PassStmt:4())
  ExpressionStmt:5(
    CastExpr:5(
      NameExpr(C [__main__.C])
      __main__.C[builtins.str, builtins.int])))

[case testCastToTupleType]
from typing import Tuple, cast
cast(Tuple[int, str], None)
[out]
MypyFile:1(
  ImportFrom:1(typing, [Tuple, cast])
  ExpressionStmt:2(
    CastExpr:2(
      NameExpr(None [builtins.None])
      Tuple[builtins.int, builtins.str])))

[case testCastToFunctionType]
from typing import Callable, cast
cast(Callable[[int], str], None)
[out]
MypyFile:1(
  ImportFrom:1(typing, [Callable, cast])
  ExpressionStmt:2(
    CastExpr:2(
      NameExpr(None [builtins.None])
      def (builtins.int) -> builtins.str)))

[case testCastToStringLiteralType]
from typing import cast
cast('int', 1)
[out]
MypyFile:1(
  ImportFrom:1(typing, [cast])
  ExpressionStmt:2(
    CastExpr:2(
      IntExpr(1)
      builtins.int)))

[case testFunctionTypeVariable]
from typing import TypeVar
t = TypeVar('t')
def f(x: t) -> None:
  y = None # type: t
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar])
  AssignmentStmt:2(
    NameExpr(t* [__main__.t])
    TypeVarExpr:2())
  FuncDef:3(
    f
    Args(
      Var(x))
    def [t] (x: t`-1)
    Block:3(
      AssignmentStmt:4(
        NameExpr(y [l])
        NameExpr(None [builtins.None])
        t`-1))))

[case testTwoFunctionTypeVariables]
from typing import TypeVar
t = TypeVar('t')
u = TypeVar('u')
def f(x: t, y: u, z: t) -> None: pass
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar])
  AssignmentStmt:2(
    NameExpr(t* [__main__.t])
    TypeVarExpr:2())
  AssignmentStmt:3(
    NameExpr(u* [__main__.u])
    TypeVarExpr:3())
  FuncDef:4(
    f
    Args(
      Var(x)
      Var(y)
      Var(z))
    def [t, u] (x: t`-1, y: u`-2, z: t`-1)
    Block:4(
      PassStmt:4())))

[case testNestedGenericFunctionTypeVariable]
from typing import TypeVar, Generic
t = TypeVar('t')
class A(Generic[t]): pass
def f(x: A[t], y) -> None: pass
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar, Generic])
  AssignmentStmt:2(
    NameExpr(t* [__main__.t])
    TypeVarExpr:2())
  ClassDef:3(
    A
    TypeVars(
      t)
    PassStmt:3())
  FuncDef:4(
    f
    Args(
      Var(x)
      Var(y))
    def [t] (x: __main__.A[t`-1], y: Any)
    Block:4(
      PassStmt:4())))

[case testNestedGenericFunctionTypeVariable2]
from typing import TypeVar, Tuple, Generic
t = TypeVar('t')
class A(Generic[t]): pass
def f(x: Tuple[int, t]) -> None: pass
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar, Tuple, Generic])
  AssignmentStmt:2(
    NameExpr(t* [__main__.t])
    TypeVarExpr:2())
  ClassDef:3(
    A
    TypeVars(
      t)
    PassStmt:3())
  FuncDef:4(
    f
    Args(
      Var(x))
    def [t] (x: Tuple[builtins.int, t`-1])
    Block:4(
      PassStmt:4())))

[case testNestedGenericFunctionTypeVariable3]
from typing import TypeVar, Callable, Generic
t = TypeVar('t')
class A(Generic[t]): pass
def f(x: Callable[[int, t], int]) -> None: pass
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar, Callable, Generic])
  AssignmentStmt:2(
    NameExpr(t* [__main__.t])
    TypeVarExpr:2())
  ClassDef:3(
    A
    TypeVars(
      t)
    PassStmt:3())
  FuncDef:4(
    f
    Args(
      Var(x))
    def [t] (x: def (builtins.int, t`-1) -> builtins.int)
    Block:4(
      PassStmt:4())))

[case testNestedGenericFunctionTypeVariable4]
from typing import TypeVar, Callable, Generic
t = TypeVar('t')
class A(Generic[t]): pass
def f(x: Callable[[], t]) -> None: pass
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar, Callable, Generic])
  AssignmentStmt:2(
    NameExpr(t* [__main__.t])
    TypeVarExpr:2())
  ClassDef:3(
    A
    TypeVars(
      t)
    PassStmt:3())
  FuncDef:4(
    f
    Args(
      Var(x))
    def [t] (x: def () -> t`-1)
    Block:4(
      PassStmt:4())))

[case testGenericFunctionTypeVariableInReturnType]
from typing import TypeVar
t = TypeVar('t')
def f() -> t: pass
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar])
  AssignmentStmt:2(
    NameExpr(t* [__main__.t])
    TypeVarExpr:2())
  FuncDef:3(
    f
    def [t] () -> t`-1
    Block:3(
      PassStmt:3())))

[case testSelfType]
class A:
  def f(self, o: object) -> None: pass
[out]
MypyFile:1(
  ClassDef:1(
    A
    FuncDef:2(
      f
      Args(
        Var(self)
        Var(o))
      def (self: __main__.A, o: builtins.object)
      Block:2(
        PassStmt:2()))))

[case testNestedGenericFunction]
from typing import TypeVar
t = TypeVar('t')
def f() -> None:
    def g() -> t: pass
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar])
  AssignmentStmt:2(
    NameExpr(t* [__main__.t])
    TypeVarExpr:2())
  FuncDef:3(
    f
    def ()
    Block:3(
      FuncDef:4(
        g
        def [t] () -> t`-1
        Block:4(
          PassStmt:4())))))

[case testClassTvar]
from typing import TypeVar, Generic

t = TypeVar('t')

class c(Generic[t]):
  def f(self) -> t: pass
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar, Generic])
  AssignmentStmt:3(
    NameExpr(t* [__main__.t])
    TypeVarExpr:3())
  ClassDef:5(
    c
    TypeVars(
      t)
    FuncDef:6(
      f
      Args(
        Var(self))
      def (self: __main__.c[t`1]) -> t`1
      Block:6(
        PassStmt:6()))))

[case testClassTvar2]
from typing import TypeVar, Generic

t = TypeVar('t')
s = TypeVar('s')

class c(Generic[t, s]):
  def f(self, x: s) -> t: pass
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar, Generic])
  AssignmentStmt:3(
    NameExpr(t* [__main__.t])
    TypeVarExpr:3())
  AssignmentStmt:4(
    NameExpr(s* [__main__.s])
    TypeVarExpr:4())
  ClassDef:6(
    c
    TypeVars(
      t
      s)
    FuncDef:7(
      f
      Args(
        Var(self)
        Var(x))
      def (self: __main__.c[t`1, s`2], x: s`2) -> t`1
      Block:7(
        PassStmt:7()))))

[case testGenericBaseClass]
from typing import TypeVar, Generic
t = TypeVar('t')
class d(Generic[t]): pass
class c(d[t], Generic[t]): pass
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar, Generic])
  AssignmentStmt:2(
    NameExpr(t* [__main__.t])
    TypeVarExpr:2())
  ClassDef:3(
    d
    TypeVars(
      t)
    PassStmt:3())
  ClassDef:4(
    c
    TypeVars(
      t)
    BaseType(
      __main__.d[t`1])
    PassStmt:4()))

[case testTupleType]
from typing import Tuple
t = None # type: tuple
t1 = None # type: Tuple[object]
t2 = None # type: Tuple[int, object]
[builtins fixtures/tuple.pyi]
[out]
MypyFile:1(
  ImportFrom:1(typing, [Tuple])
  AssignmentStmt:2(
    NameExpr(t [__main__.t])
    NameExpr(None [builtins.None])
    builtins.tuple[Any])
  AssignmentStmt:3(
    NameExpr(t1 [__main__.t1])
    NameExpr(None [builtins.None])
    Tuple[builtins.object])
  AssignmentStmt:4(
    NameExpr(t2 [__main__.t2])
    NameExpr(None [builtins.None])
    Tuple[builtins.int, builtins.object]))

[case testVariableLengthTuple]
from typing import Tuple
t = None # type: Tuple[int, ...]
[builtins fixtures/tuple.pyi]
[out]
MypyFile:1(
  ImportFrom:1(typing, [Tuple])
  AssignmentStmt:2(
    NameExpr(t [__main__.t])
    NameExpr(None [builtins.None])
    builtins.tuple[builtins.int]))

[case testInvalidTupleType]
from typing import Tuple
t = None # type: Tuple[int, str, ...] # E: Unexpected '...'
[out]

[case testFunctionTypes]
from typing import Callable
f = None # type: Callable[[object, int], str]
g = None # type: Callable[[], None]
[out]
MypyFile:1(
  ImportFrom:1(typing, [Callable])
  AssignmentStmt:2(
    NameExpr(f [__main__.f])
    NameExpr(None [builtins.None])
    def (builtins.object, builtins.int) -> builtins.str)
  AssignmentStmt:3(
    NameExpr(g [__main__.g])
    NameExpr(None [builtins.None])
    def ()))

[case testOverloadedFunction]
from typing import overload, Any
@overload
def f(a: object) -> int: a
@overload
def f(a: str) -> object: a

def f(a: Any) -> Any: return a

[out]
MypyFile:1(
  ImportFrom:1(typing, [overload, Any])
  OverloadedFuncDef:2(
    FuncDef:7(
      f
      Args(
        Var(a))
      def (a: Any) -> Any
      Block:7(
        ReturnStmt:7(
          NameExpr(a [l]))))
    Overload(def (a: builtins.object) -> builtins.int, \
             def (a: builtins.str) -> builtins.object)
    Decorator:2(
      Var(f)
      NameExpr(overload [typing.overload])
      FuncDef:3(
        f
        Args(
          Var(a))
        def (a: builtins.object) -> builtins.int
        Block:3(
          ExpressionStmt:3(
            NameExpr(a [l])))))
    Decorator:4(
      Var(f)
      NameExpr(overload [typing.overload])
      FuncDef:5(
        f
        Args(
          Var(a))
        def (a: builtins.str) -> builtins.object
        Block:5(
          ExpressionStmt:5(
            NameExpr(a [l])))))))

[case testReferenceToOverloadedFunction]
from typing import overload
@overload
def f() -> None: pass
@overload
def f(x: int) -> None: pass

def f(*args) -> None: pass

x = f
[out]
MypyFile:1(
  ImportFrom:1(typing, [overload])
  OverloadedFuncDef:2(
    FuncDef:7(
      f
      def (*args: Any)
      VarArg(
        Var(args))
      Block:7(
        PassStmt:7()))
    Overload(def (), def (x: builtins.int))
    Decorator:2(
      Var(f)
      NameExpr(overload [typing.overload])
      FuncDef:3(
        f
        def ()
        Block:3(
          PassStmt:3())))
    Decorator:4(
      Var(f)
      NameExpr(overload [typing.overload])
      FuncDef:5(
        f
        Args(
          Var(x))
        def (x: builtins.int)
        Block:5(
          PassStmt:5()))))
  AssignmentStmt:9(
    NameExpr(x* [__main__.x])
    NameExpr(f [__main__.f])))

[case testNestedOverloadedFunction]
from typing import overload
def f():
    @overload
    def g(): pass
    @overload
    def g(x): pass

    def g(*args): pass

    y = g
[out]
MypyFile:1(
  ImportFrom:1(typing, [overload])
  FuncDef:2(
    f
    Block:2(
      OverloadedFuncDef:3(
        FuncDef:8(
          g
          VarArg(
            Var(args))
          Block:8(
            PassStmt:8()))
        Overload(def () -> Any, def (x: Any) -> Any)
        Decorator:3(
          Var(g)
          NameExpr(overload [typing.overload])
          FuncDef:4(
            g
            Block:4(
              PassStmt:4())))
        Decorator:5(
          Var(g)
          NameExpr(overload [typing.overload])
          FuncDef:6(
            g
            Args(
              Var(x))
            Block:6(
              PassStmt:6()))))
      AssignmentStmt:10(
        NameExpr(y* [l])
        NameExpr(g [l])))))

[case testImplicitGenericTypeArgs]
from typing import TypeVar, Generic
t = TypeVar('t')
s = TypeVar('s')
class A(Generic[t, s]): pass
x = None # type: A
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar, Generic])
  AssignmentStmt:2(
    NameExpr(t* [__main__.t])
    TypeVarExpr:2())
  AssignmentStmt:3(
    NameExpr(s* [__main__.s])
    TypeVarExpr:3())
  ClassDef:4(
    A
    TypeVars(
      t
      s)
    PassStmt:4())
  AssignmentStmt:5(
    NameExpr(x [__main__.x])
    NameExpr(None [builtins.None])
    __main__.A[Any, Any]))

[case testImplicitTypeArgsAndGenericBaseClass]
from typing import TypeVar, Generic
t = TypeVar('t')
s = TypeVar('s')
class B(Generic[s]): pass
class A(B, Generic[t]): pass
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar, Generic])
  AssignmentStmt:2(
    NameExpr(t* [__main__.t])
    TypeVarExpr:2())
  AssignmentStmt:3(
    NameExpr(s* [__main__.s])
    TypeVarExpr:3())
  ClassDef:4(
    B
    TypeVars(
      s)
    PassStmt:4())
  ClassDef:5(
    A
    TypeVars(
      t)
    BaseType(
      __main__.B[Any])
    PassStmt:5()))

[case testTypeApplication]
from typing import TypeVar, Generic
t = TypeVar('t')
class A(Generic[t]): pass
x = A[int]()
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar, Generic])
  AssignmentStmt:2(
    NameExpr(t* [__main__.t])
    TypeVarExpr:2())
  ClassDef:3(
    A
    TypeVars(
      t)
    PassStmt:3())
  AssignmentStmt:4(
    NameExpr(x* [__main__.x])
    CallExpr:4(
      TypeApplication:4(
        NameExpr(A [__main__.A])
        Types(
          builtins.int))
      Args())))

[case testTypeApplicationWithTwoTypeArgs]
from typing import TypeVar, Generic, Any
t = TypeVar('t')
s = TypeVar('s')
class A(Generic[t, s]): pass
x = A[int, Any]()
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar, Generic, Any])
  AssignmentStmt:2(
    NameExpr(t* [__main__.t])
    TypeVarExpr:2())
  AssignmentStmt:3(
    NameExpr(s* [__main__.s])
    TypeVarExpr:3())
  ClassDef:4(
    A
    TypeVars(
      t
      s)
    PassStmt:4())
  AssignmentStmt:5(
    NameExpr(x* [__main__.x])
    CallExpr:5(
      TypeApplication:5(
        NameExpr(A [__main__.A])
        Types(
          builtins.int
          Any))
      Args())))

[case testFunctionTypeApplication]
from typing import TypeVar
t = TypeVar('t')
def f(x: t) -> None: pass
f[int](1)
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar])
  AssignmentStmt:2(
    NameExpr(t* [__main__.t])
    TypeVarExpr:2())
  FuncDef:3(
    f
    Args(
      Var(x))
    def [t] (x: t`-1)
    Block:3(
      PassStmt:3()))
  ExpressionStmt:4(
    CallExpr:4(
      TypeApplication:4(
        NameExpr(f [__main__.f])
        Types(
          builtins.int))
      Args(
        IntExpr(1)))))

[case testTypeApplicationWithStringLiteralType]
from typing import TypeVar, Generic
t = TypeVar('t')
class A(Generic[t]): pass
A['int']()
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar, Generic])
  AssignmentStmt:2(
    NameExpr(t* [__main__.t])
    TypeVarExpr:2())
  ClassDef:3(
    A
    TypeVars(
      t)
    PassStmt:3())
  ExpressionStmt:4(
    CallExpr:4(
      TypeApplication:4(
        NameExpr(A [__main__.A])
        Types(
          builtins.int))
      Args())))

[case testVarArgsAndKeywordArgs]
def g(*x: int, y: str = ''): pass
[out]
MypyFile:1(
  FuncDef:1(
    g
    MaxPos(0)
    Args(
      default(
        Var(y)
        StrExpr()))
    def (*x: builtins.int, *, y: builtins.str =) -> Any
    VarArg(
      Var(x))
    Block:1(
      PassStmt:1())))

[case testQualifiedGeneric]
from typing import TypeVar
import typing
T = TypeVar('T')
class A(typing.Generic[T]): pass
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar])
  Import:2(typing)
  AssignmentStmt:3(
    NameExpr(T* [__main__.T])
    TypeVarExpr:3())
  ClassDef:4(
    A
    TypeVars(
      T)
    PassStmt:4()))

[case testQualifiedTypevar]
import typing
T = typing.TypeVar('T')
def f(x: T) -> T: pass
[out]
MypyFile:1(
  Import:1(typing)
  AssignmentStmt:2(
    NameExpr(T* [__main__.T])
    TypeVarExpr:2())
  FuncDef:3(
    f
    Args(
      Var(x))
    def [T] (x: T`-1) -> T`-1
    Block:3(
      PassStmt:3())))

[case testAliasedTypevar]
from typing import TypeVar as tv
T = tv('T')
def f(x: T) -> T: pass
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar : tv])
  AssignmentStmt:2(
    NameExpr(T* [__main__.T])
    TypeVarExpr:2())
  FuncDef:3(
    f
    Args(
      Var(x))
    def [T] (x: T`-1) -> T`-1
    Block:3(
      PassStmt:3())))

[case testLocalTypevar]
from typing import TypeVar
def f():
    T = TypeVar('T')
    def g(x: T) -> T: pass
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar])
  FuncDef:2(
    f
    Block:2(
      AssignmentStmt:3(
        NameExpr(T* [l])
        TypeVarExpr:3())
      FuncDef:4(
        g
        Args(
          Var(x))
        def [T] (x: T`-1) -> T`-1
        Block:4(
          PassStmt:4())))))

[case testClassLevelTypevar]
from typing import TypeVar
class A:
    T = TypeVar('T')
    def g(self, x: T) -> T: pass
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar])
  ClassDef:2(
    A
    AssignmentStmt:3(
      NameExpr(T* [m])
      TypeVarExpr:3())
    FuncDef:4(
      g
      Args(
        Var(self)
        Var(x))
      def [T] (self: __main__.A, x: T`-1) -> T`-1
      Block:4(
        PassStmt:4()))))

[case testImportTypevar]
from typing import Generic
from _m import T
class A(Generic[T]):
    y = None # type: T
[file _m.py]
from typing import TypeVar
T = TypeVar('T')
[out]
MypyFile:1(
  ImportFrom:1(typing, [Generic])
  ImportFrom:2(_m, [T])
  ClassDef:3(
    A
    TypeVars(
      T)
    AssignmentStmt:4(
      NameExpr(y [m])
      NameExpr(None [builtins.None])
      T`1)))

[case testQualifiedReferenceToTypevarInClass]
from typing import Generic
import _m
class A(Generic[_m.T]):
    a = None # type: _m.T
    def f(self, x: _m.T):
        b = None # type: _m.T
[file _m.py]
from typing import TypeVar
T = TypeVar('T')
[out]
MypyFile:1(
  ImportFrom:1(typing, [Generic])
  Import:2(_m)
  ClassDef:3(
    A
    TypeVars(
      _m.T)
    AssignmentStmt:4(
      NameExpr(a [m])
      NameExpr(None [builtins.None])
      _m.T`1)
    FuncDef:5(
      f
      Args(
        Var(self)
        Var(x))
      def (self: __main__.A[_m.T`1], x: _m.T`1) -> Any
      Block:5(
        AssignmentStmt:6(
          NameExpr(b [l])
          NameExpr(None [builtins.None])
          _m.T`1)))))

[case testQualifiedReferenceToTypevarInFunctionSignature]
import _m
def f(x: _m.T) -> None:
    a = None # type: _m.T
[file _m.py]
from typing import TypeVar
T = TypeVar('T')
[out]
MypyFile:1(
  Import:1(_m)
  FuncDef:2(
    f
    Args(
      Var(x))
    def [_m.T] (x: _m.T`-1)
    Block:2(
      AssignmentStmt:3(
        NameExpr(a [l])
        NameExpr(None [builtins.None])
        _m.T`-1))))

[case testFunctionCommentAnnotation]
from typing import Any
def f(x): # type: (int) -> Any
  x = 1
[out]
MypyFile:1(
  ImportFrom:1(typing, [Any])
  FuncDef:2(
    f
    Args(
      Var(x))
    def (x: builtins.int) -> Any
    Block:2(
      AssignmentStmt:3(
        NameExpr(x [l])
        IntExpr(1)))))

[case testMethodCommentAnnotation]
import typing
class A:
  def f(self, x): # type: (int) -> str
    x = 1
[out]
MypyFile:1(
  Import:1(typing)
  ClassDef:2(
    A
    FuncDef:3(
      f
      Args(
        Var(self)
        Var(x))
      def (self: __main__.A, x: builtins.int) -> builtins.str
      Block:3(
        AssignmentStmt:4(
          NameExpr(x [l])
          IntExpr(1))))))

[case testTypevarWithValues]
from typing import TypeVar, Any
T = TypeVar('T', int, str)
S = TypeVar('S', Any, int, str)
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar, Any])
  AssignmentStmt:2(
    NameExpr(T* [__main__.T])
    TypeVarExpr:2(
      Values(
        builtins.int
        builtins.str)))
  AssignmentStmt:3(
    NameExpr(S* [__main__.S])
    TypeVarExpr:3(
      Values(
        Any
        builtins.int
        builtins.str))))

[case testTypevarWithValuesAndVariance]
from typing import TypeVar
T = TypeVar('T', int, str, covariant=True)
[builtins fixtures/bool.pyi]
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar])
  AssignmentStmt:2(
    NameExpr(T* [__main__.T])
    TypeVarExpr:2(
      Variance(COVARIANT)
      Values(
        builtins.int
        builtins.str))))

[case testTypevarWithBound]
from typing import TypeVar
T = TypeVar('T', bound=int)
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar])
  AssignmentStmt:2(
    NameExpr(T* [__main__.T])
    TypeVarExpr:2(
      UpperBound(builtins.int))))

[case testGenericFunctionWithValueSet]
from typing import TypeVar
T = TypeVar('T', int, str)
def f(x: T) -> T: pass
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar])
  AssignmentStmt:2(
    NameExpr(T* [__main__.T])
    TypeVarExpr:2(
      Values(
        builtins.int
        builtins.str)))
  FuncDef:3(
    f
    Args(
      Var(x))
    def [T in (builtins.int, builtins.str)] (x: T`-1) -> T`-1
    Block:3(
      PassStmt:3())))

[case testGenericClassWithValueSet]
from typing import TypeVar, Generic
T = TypeVar('T', int, str)
class C(Generic[T]): pass
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar, Generic])
  AssignmentStmt:2(
    NameExpr(T* [__main__.T])
    TypeVarExpr:2(
      Values(
        builtins.int
        builtins.str)))
  ClassDef:3(
    C
    TypeVars(
      T in (builtins.int, builtins.str))
    PassStmt:3()))

[case testGenericFunctionWithBound]
from typing import TypeVar
T = TypeVar('T', bound=int)
def f(x: T) -> T: pass
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar])
  AssignmentStmt:2(
    NameExpr(T* [__main__.T])
    TypeVarExpr:2(
      UpperBound(builtins.int)))
  FuncDef:3(
    f
    Args(
      Var(x))
    def [T <: builtins.int] (x: T`-1) -> T`-1
    Block:3(
      PassStmt:3())))

[case testGenericClassWithBound]
from typing import TypeVar, Generic
T = TypeVar('T', bound=int)
class C(Generic[T]): pass
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar, Generic])
  AssignmentStmt:2(
    NameExpr(T* [__main__.T])
    TypeVarExpr:2(
      UpperBound(builtins.int)))
  ClassDef:3(
    C
    TypeVars(
      T <: builtins.int)
    PassStmt:3()))

[case testSimpleDucktypeDecorator]
from typing import _promote
@_promote(str)
class S: pass
[out]
MypyFile:1(
  ImportFrom:1(typing, [_promote])
  ClassDef:2(
    S
    Promote(builtins.str)
    Decorators(
      PromoteExpr:2(builtins.str))
    PassStmt:3()))

[case testUnionType]
from typing import Union
def f(x: Union[int, str]) -> None: pass
[out]
MypyFile:1(
  ImportFrom:1(typing, [Union])
  FuncDef:2(
    f
    Args(
      Var(x))
    def (x: Union[builtins.int, builtins.str])
    Block:2(
      PassStmt:2())))

[case testUnionTypeWithNoneItem]
from typing import Union
def f(x: Union[int, None]) -> None: pass
[out]
MypyFile:1(
  ImportFrom:1(typing, [Union])
  FuncDef:2(
    f
    Args(
      Var(x))
    def (x: Union[builtins.int, None])
    Block:2(
      PassStmt:2())))

[case testUnionTypeWithNoneItemAndTwoItems]
from typing import Union
def f(x: Union[int, None, str]) -> None: pass
[out]
MypyFile:1(
  ImportFrom:1(typing, [Union])
  FuncDef:2(
    f
    Args(
      Var(x))
    def (x: Union[builtins.int, None, builtins.str])
    Block:2(
      PassStmt:2())))

[case testUnionTypeWithSingleItem]
from typing import Union
def f(x: Union[int]) -> None: pass
[out]
MypyFile:1(
  ImportFrom:1(typing, [Union])
  FuncDef:2(
    f
    Args(
      Var(x))
    def (x: builtins.int)
    Block:2(
      PassStmt:2())))

[case testOptionalTypes]
from typing import Optional
x = 1  # type: Optional[int]
[out]
MypyFile:1(
  ImportFrom:1(typing, [Optional])
  AssignmentStmt:2(
    NameExpr(x [__main__.x])
    IntExpr(1)
    Union[builtins.int, None]))

[case testInvalidOptionalType]
from typing import Optional
x = 1  # type: Optional[int, str]  # E: Optional[...] must have exactly one type argument
y = 1  # type: Optional  # E: Optional[...] must have exactly one type argument
[out]

[case testCoAndContravariantTypeVar]
from typing import TypeVar
T = TypeVar('T', covariant=True)
S = TypeVar('S', contravariant=True)
[builtins fixtures/bool.pyi]
[out]
MypyFile:1(
  ImportFrom:1(typing, [TypeVar])
  AssignmentStmt:2(
    NameExpr(T* [__main__.T])
    TypeVarExpr:2(
      Variance(COVARIANT)))
  AssignmentStmt:3(
    NameExpr(S* [__main__.S])
    TypeVarExpr:3(
      Variance(CONTRAVARIANT))))

[case testTupleExpressionAsType]
def f(x: (int, int)) -> None: pass
[out]
main:1: error: Syntax error in type annotation
main:1: note: Suggestion: Use Tuple[T1, ..., Tn] instead of (T1, ..., Tn)

[case tesQualifiedTypeNameBasedOnAny]
from typing import Any
x = 0 # type: Any
z = 0 # type: x.y
[out]
MypyFile:1(
  ImportFrom:1(typing, [Any])
  AssignmentStmt:2(
    NameExpr(x [__main__.x])
    IntExpr(0)
    Any)
  AssignmentStmt:3(
    NameExpr(z [__main__.z])
    IntExpr(0)
    Any))
