[case testEmptyFile]
[out]
MypyFile:1()

[case testGlobalVariable]
x = 1
x
[out]
MypyFile:1(
  AssignmentStmt:1(
    NameExpr(x [__main__.x])
    IntExpr(1)
    builtins.int)
  ExpressionStmt:2(
    NameExpr(x [__main__.x])))

[case testMultipleGlobals]
x = y = 2
z = 3
(x, y, z)
[out]
MypyFile:1(
  AssignmentStmt:1(
    Lvalues(
      NameExpr(x* [__main__.x])
      NameExpr(y* [__main__.y]))
    IntExpr(2))
  AssignmentStmt:2(
    NameExpr(z [__main__.z])
    IntExpr(3)
    builtins.int)
  ExpressionStmt:3(
    TupleExpr:3(
      NameExpr(x [__main__.x])
      NameExpr(y [__main__.y])
      NameExpr(z [__main__.z]))))

[case testEmptyFunction]
def f(): pass
f()
[out]
MypyFile:1(
  FuncDef:1(
    f
    Block:1(
      PassStmt:1()))
  ExpressionStmt:2(
    CallExpr:2(
      NameExpr(f [__main__.f])
      Args())))

[case testAccessingGlobalNameBeforeDefinition]
# flags: --disable-error-code used-before-def
x
f()
x = 1
def f(): pass
[out]
MypyFile:1(
  ExpressionStmt:2(
    NameExpr(x [__main__.x]))
  ExpressionStmt:3(
    CallExpr:3(
      NameExpr(f [__main__.f])
      Args()))
  AssignmentStmt:4(
    NameExpr(x [__main__.x])
    IntExpr(1)
    builtins.int)
  FuncDef:5(
    f
    Block:5(
      PassStmt:5())))

[case testFunctionArgs]
def f(x, y):
  (x, y)
[out]
MypyFile:1(
  FuncDef:1(
    f
    Args(
      Var(x)
      Var(y))
    Block:2(
      ExpressionStmt:2(
        TupleExpr:2(
          NameExpr(x [l])
          NameExpr(y [l]))))))

[case testLocalVar]
def f():
  x = 1
  x
[out]
MypyFile:1(
  FuncDef:1(
    f
    Block:2(
      AssignmentStmt:2(
        NameExpr(x* [l])
        IntExpr(1))
      ExpressionStmt:3(
        NameExpr(x [l])))))

[case testAccessGlobalInFn]
def f():
  x
  g()
x = 1
def g(): pass
[out]
MypyFile:1(
  FuncDef:1(
    f
    Block:2(
      ExpressionStmt:2(
        NameExpr(x [__main__.x]))
      ExpressionStmt:3(
        CallExpr:3(
          NameExpr(g [__main__.g])
          Args()))))
  AssignmentStmt:4(
    NameExpr(x [__main__.x])
    IntExpr(1)
    builtins.int)
  FuncDef:5(
    g
    Block:5(
      PassStmt:5())))

[case testAssignmentAfterInit]
x = 1
x = 2
def f(y):
  y = 1
  z = 1
  z = 2
[out]
MypyFile:1(
  AssignmentStmt:1(
    NameExpr(x [__main__.x])
    IntExpr(1)
    builtins.int)
  AssignmentStmt:2(
    NameExpr(x [__main__.x])
    IntExpr(2))
  FuncDef:3(
    f
    Args(
      Var(y))
    Block:4(
      AssignmentStmt:4(
        NameExpr(y [l])
        IntExpr(1))
      AssignmentStmt:5(
        NameExpr(z* [l])
        IntExpr(1))
      AssignmentStmt:6(
        NameExpr(z [l])
        IntExpr(2)))))

[case testLocalAndGlobalAliasing]
x = 1
def f():
  x = 2
  x
x
[out]
MypyFile:1(
  AssignmentStmt:1(
    NameExpr(x [__main__.x])
    IntExpr(1)
    builtins.int)
  FuncDef:2(
    f
    Block:3(
      AssignmentStmt:3(
        NameExpr(x* [l])
        IntExpr(2))
      ExpressionStmt:4(
        NameExpr(x [l]))))
  ExpressionStmt:5(
    NameExpr(x [__main__.x])))

[case testArgumentInitializers]
def f(x = f, y = object):
  x, y
[out]
MypyFile:1(
  FuncDef:1(
    f
    Args(
      default(
        Var(x)
        NameExpr(f [__main__.f]))
      default(
        Var(y)
        NameExpr(object [builtins.object])))
    Block:2(
      ExpressionStmt:2(
        TupleExpr:2(
          NameExpr(x [l])
          NameExpr(y [l]))))))

[case testVarArgs]
def f(x, *y):
  x, y
[out]
MypyFile:1(
  FuncDef:1(
    f
    Args(
      Var(x))
    VarArg(
      Var(y))
    Block:2(
      ExpressionStmt:2(
        TupleExpr:2(
          NameExpr(x [l])
          NameExpr(y [l]))))))

[case testGlobalDecl]
x = None
def f():
    global x
    x = None
    x
class A: pass
[out]
MypyFile:1(
  AssignmentStmt:1(
    NameExpr(x* [__main__.x])
    NameExpr(None [builtins.None]))
  FuncDef:2(
    f
    Block:3(
      GlobalDecl:3(
        x)
      AssignmentStmt:4(
        NameExpr(x [__main__.x])
        NameExpr(None [builtins.None]))
      ExpressionStmt:5(
        NameExpr(x [__main__.x]))))
  ClassDef:6(
    A
    PassStmt:6()))

[case testMultipleNamesInGlobalDecl]
x, y = None, None
def f():
    global x, y
    x = y
[out]
MypyFile:1(
  AssignmentStmt:1(
    TupleExpr:1(
      NameExpr(x* [__main__.x])
      NameExpr(y* [__main__.y]))
    TupleExpr:1(
      NameExpr(None [builtins.None])
      NameExpr(None [builtins.None])))
  FuncDef:2(
    f
    Block:3(
      GlobalDecl:3(
        x
        y)
      AssignmentStmt:4(
        NameExpr(x [__main__.x])
        NameExpr(y [__main__.y])))))

[case testGlobalDeclScope]
x = None
def f():
    global x
def g():
    x = None
[out]
MypyFile:1(
  AssignmentStmt:1(
    NameExpr(x* [__main__.x])
    NameExpr(None [builtins.None]))
  FuncDef:2(
    f
    Block:3(
      GlobalDecl:3(
        x)))
  FuncDef:4(
    g
    Block:5(
      AssignmentStmt:5(
        NameExpr(x* [l])
        NameExpr(None [builtins.None])))))

[case testGlobalDeclScope2]
x = None
def f():
    global x
def g():
    x = None
[out]
MypyFile:1(
  AssignmentStmt:1(
    NameExpr(x* [__main__.x])
    NameExpr(None [builtins.None]))
  FuncDef:2(
    f
    Block:3(
      GlobalDecl:3(
        x)))
  FuncDef:4(
    g
    Block:5(
      AssignmentStmt:5(
        NameExpr(x* [l])
        NameExpr(None [builtins.None])))))

[case testGlobaWithinMethod]
x = None
class A:
  def f(self):
    global x
    x = self
[out]
MypyFile:1(
  AssignmentStmt:1(
    NameExpr(x* [__main__.x])
    NameExpr(None [builtins.None]))
  ClassDef:2(
    A
    FuncDef:3(
      f
      Args(
        Var(self))
      Block:4(
        GlobalDecl:4(
          x)
        AssignmentStmt:5(
          NameExpr(x [__main__.x])
          NameExpr(self [l]))))))

[case testGlobalDefinedInBlock]
# flags: --allow-redefinition
if object:
    x = object()
    x = x
x
[out]
MypyFile:1(
  IfStmt:2(
    If(
      NameExpr(object [builtins.object]))
    Then(
      AssignmentStmt:3(
        NameExpr(x'* [__main__.x'])
        CallExpr:3(
          NameExpr(object [builtins.object])
          Args()))
      AssignmentStmt:4(
        NameExpr(x* [__main__.x])
        NameExpr(x' [__main__.x']))))
  ExpressionStmt:5(
    NameExpr(x [__main__.x])))

[case testNonlocalDecl]
def g():
    x = None
    def f():
        nonlocal x
        x = None
        x
[out]
MypyFile:1(
  FuncDef:1(
    g
    Block:2(
      AssignmentStmt:2(
        NameExpr(x* [l])
        NameExpr(None [builtins.None]))
      FuncDef:3(
        f
        Block:4(
          NonlocalDecl:4(
            x)
          AssignmentStmt:5(
            NameExpr(x [l])
            NameExpr(None [builtins.None]))
          ExpressionStmt:6(
            NameExpr(x [l])))))))

[case testNonlocalClass]
def f() -> None:
    a = 0
    class C:
        nonlocal a
        a = 1
[out]
MypyFile:1(
  FuncDef:1(
    f
    def ()
    Block:2(
      AssignmentStmt:2(
        NameExpr(a* [l])
        IntExpr(0))
      ClassDef:3(
        C
        NonlocalDecl:4(
          a)
        AssignmentStmt:5(
          NameExpr(a* [m])
          IntExpr(1))))))

[case testMultipleNamesInNonlocalDecl]
def g():
    x, y = None, None
    def f(z):
        nonlocal x, y
        x = y
[out]
MypyFile:1(
  FuncDef:1(
    g
    Block:2(
      AssignmentStmt:2(
        TupleExpr:2(
          NameExpr(x* [l])
          NameExpr(y* [l]))
        TupleExpr:2(
          NameExpr(None [builtins.None])
          NameExpr(None [builtins.None])))
      FuncDef:3(
        f
        Args(
          Var(z))
        Block:4(
          NonlocalDecl:4(
            x
            y)
          AssignmentStmt:5(
            NameExpr(x [l])
            NameExpr(y [l])))))))

[case testNestedFunctions]
def f(x):
    def g(y):
        z = y + x
    return g
[out]
MypyFile:1(
  FuncDef:1(
    f
    Args(
      Var(x))
    Block:2(
      FuncDef:2(
        g
        Args(
          Var(y))
        Block:3(
          AssignmentStmt:3(
            NameExpr(z* [l])
            OpExpr:3(
              +
              NameExpr(y [l])
              NameExpr(x [l])))))
      ReturnStmt:4(
        NameExpr(g [l])))))

[case testNestedFunctionWithOverlappingName]
def f(x):
    def g():
        x = 1
[out]
MypyFile:1(
  FuncDef:1(
    f
    Args(
      Var(x))
    Block:2(
      FuncDef:2(
        g
        Block:3(
          AssignmentStmt:3(
            NameExpr(x* [l])
            IntExpr(1)))))))

[case testFinalValuesOnVar]
from typing import Final, Any

def func() -> Any: ...
x: Final = 1
y: Final = 1.0
s: Final = "hi"
t: Final = True
n: Final = func()
[out]
MypyFile:1(
  ImportFrom:1(typing, [Final, Any])
  FuncDef:3(
    func
    def () -> Any
    Block:3(
      ExpressionStmt:3(
        Ellipsis)))
  AssignmentStmt:4(
    NameExpr(x [__main__.x] = 1)
    IntExpr(1)
    Literal[1]?)
  AssignmentStmt:5(
    NameExpr(y [__main__.y] = 1.0)
    FloatExpr(1.0)
    Literal[1.0]?)
  AssignmentStmt:6(
    NameExpr(s [__main__.s] = hi)
    StrExpr(hi)
    Literal['hi']?)
  AssignmentStmt:7(
    NameExpr(t [__main__.t] = True)
    NameExpr(True [builtins.True])
    Literal[True]?)
  AssignmentStmt:8(
    NameExpr(n* [__main__.n] = None)
    CallExpr:8(
      NameExpr(func [__main__.func])
      Args())))