import t, c
from stdint import *
import memhub
import string
from .base import (
    AST, Stmt, ASTKind, ASTCtx, OpKind,
    _init_ast, _copy_str, _set_parent_list,
    _emit, _emit_str, _emit_int, _dump_list,
    FLAG_IS_ASYNC, _op_name
)


# ============================================================
# Module Node
# ============================================================
virtual class Module(AST):
    """Module(children: list[rawptr[AST]])"""

    def __new__(self, pool: rawptr[memhub.MemManager]):
        ptr: rawptr[Module] = pool.alloc(Module.__sizeof__())
        if ptr: string.memset(ptr, 0, Module.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager]):
        _init_ast(self, pool, 0, 0)

    def kind(self) -> int:
        return ASTKind.Module

    def type_name(self) -> str:
        return "Module"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "Module(body=")
        pos = _dump_list(self.children, buf, size, pos)
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# Assign Node
# ============================================================

class Assign(Stmt):
    """Assign(targets: list[rawptr[AST]], value: AST)"""
    targets: rawptr[list[rawptr[AST]]]
    value:   rawptr[AST]

    def __new__(self, pool: rawptr[memhub.MemManager],
                targets: rawptr[list[rawptr[AST]]], value: rawptr[AST]):
        ptr: rawptr[Assign] = pool.alloc(Assign.__sizeof__())
        if ptr: string.memset(ptr, 0, Assign.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager],
                 targets: rawptr[list[rawptr[AST]]], value: rawptr[AST]):
        _init_ast(self, pool, 0, 0)
        self.targets = targets
        self.value = value
        _set_parent_list(targets, self)

    def kind(self) -> int:
        return ASTKind.Assign

    def type_name(self) -> str:
        return "Assign"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "Assign(targets=")
        pos = _dump_list(self.targets, buf, size, pos)
        pos = _emit(buf, size, pos, ", value=")
        if self.value is not None:
            pos = self.value.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# If Node
# ============================================================

class If(Stmt):
    """If(test: AST, orelse: list[rawptr[AST]])"""
    test:   rawptr[AST]
    orelse: rawptr[list[rawptr[AST]]]

    def __new__(self, pool: rawptr[memhub.MemManager],
                test: rawptr[AST],
                orelse: rawptr[list[rawptr[AST]]]):
        ptr: rawptr[If] = pool.alloc(If.__sizeof__())
        if ptr: string.memset(ptr, 0, If.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager],
                 test: rawptr[AST],
                 orelse: rawptr[list[rawptr[AST]]]):
        _init_ast(self, pool, 0, 0)
        self.test = test
        self.orelse = orelse
        _set_parent_list(orelse, self)

    def kind(self) -> int:
        return ASTKind.If

    def type_name(self) -> str:
        return "If"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "If(test=")
        if self.test is not None:
            pos = self.test.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ", body=")
        pos = _dump_list(self.children, buf, size, pos)
        pos = _emit(buf, size, pos, ", orelse=")
        pos = _dump_list(self.orelse, buf, size, pos)
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# For Node
# ============================================================

class For(Stmt):
    """For(target: AST, iter: AST, orelse: list[rawptr[AST]], is_async: CInt)"""
    target: rawptr[AST]
    iter:   rawptr[AST]
    orelse: rawptr[list[rawptr[AST]]]
    flags:  int

    def __new__(self, pool: rawptr[memhub.MemManager],
                target: rawptr[AST], iter: rawptr[AST],
                orelse: rawptr[list[rawptr[AST]]],
                is_async: int):
        ptr: rawptr[For] = pool.alloc(For.__sizeof__())
        if ptr: string.memset(ptr, 0, For.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager],
                 target: rawptr[AST], iter: rawptr[AST],
                 orelse: rawptr[list[rawptr[AST]]],
                 is_async: int):
        _init_ast(self, pool, 0, 0)
        self.target = target
        self.iter = iter
        self.orelse = orelse
        if is_async:
            self.flags = FLAG_IS_ASYNC
        else:
            self.flags = 0
        _set_parent_list(orelse, self)

    def kind(self) -> int:
        return ASTKind.For

    def type_name(self) -> str:
        return "For"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "For(target=")
        if self.target is not None:
            pos = self.target.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ", iter=")
        if self.iter is not None:
            pos = self.iter.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ", body=")
        pos = _dump_list(self.children, buf, size, pos)
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# While Node
# ============================================================

class While(Stmt):
    """While(test: AST, orelse: list[rawptr[AST]])"""
    test:   rawptr[AST]
    orelse: rawptr[list[rawptr[AST]]]

    def __new__(self, pool: rawptr[memhub.MemManager],
                test: rawptr[AST],
                orelse: rawptr[list[rawptr[AST]]]):
        ptr: rawptr[While] = pool.alloc(While.__sizeof__())
        if ptr: string.memset(ptr, 0, While.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager],
                 test: rawptr[AST],
                 orelse: rawptr[list[rawptr[AST]]]):
        _init_ast(self, pool, 0, 0)
        self.test = test
        self.orelse = orelse
        _set_parent_list(orelse, self)

    def kind(self) -> int:
        return ASTKind.While

    def type_name(self) -> str:
        return "While"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "While(test=")
        if self.test is not None:
            pos = self.test.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ", body=")
        pos = _dump_list(self.children, buf, size, pos)
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# Return Node
# ============================================================

class Return(Stmt):
    """Return(value: AST | None)"""
    value: rawptr[AST]

    def __new__(self, pool: rawptr[memhub.MemManager], value: rawptr[AST]):
        ptr: rawptr[Return] = pool.alloc(Return.__sizeof__())
        if ptr: string.memset(ptr, 0, Return.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager], value: rawptr[AST]):
        _init_ast(self, pool, 0, 0)
        self.value = value

    def kind(self) -> int:
        return ASTKind.Return

    def type_name(self) -> str:
        return "Return"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "Return(value=")
        if self.value is not None:
            pos = self.value.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# Expr Node (expression statement)
# ============================================================

class Expr(Stmt):
    """Expr(value: AST)"""
    value: rawptr[AST]

    def __new__(self, pool: rawptr[memhub.MemManager], value: rawptr[AST]):
        ptr: rawptr[Expr] = pool.alloc(Expr.__sizeof__())
        if ptr: string.memset(ptr, 0, Expr.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager], value: rawptr[AST]):
        _init_ast(self, pool, 0, 0)
        self.value = value

    def kind(self) -> int:
        return ASTKind.Expr

    def type_name(self) -> str:
        return "Expr"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "Expr(value=")
        if self.value is not None:
            pos = self.value.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# FunctionDef Node
# ============================================================

class FunctionDef(Stmt):
    """FunctionDef(name: str, args: AST,
                   decorator_list: list[rawptr[AST]], returns: AST, flags: CInt,
                   type_params: rawptr[list[str]] = None)

    type_params: generic function type-parameter name list (the [T] in PEP 695 def f[T](...)),
                 None means a non-generic function."""
    name:            str
    args:            rawptr[AST]
    decorator_list:  rawptr[list[rawptr[AST]]]
    returns:         rawptr[AST]
    flags:           int
    type_params:     rawptr[list[str]]

    def __new__(self, pool: rawptr[memhub.MemManager],
                name: str, args: rawptr[AST],
                decorator_list: rawptr[list[rawptr[AST]]],
                returns: rawptr[AST], is_async: int):
        ptr: rawptr[FunctionDef] = pool.alloc(FunctionDef.__sizeof__())
        if ptr: string.memset(ptr, 0, FunctionDef.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager],
                 name: str, args: rawptr[AST],
                 decorator_list: rawptr[list[rawptr[AST]]],
                 returns: rawptr[AST], is_async: int,
                 type_params: rawptr[list[str]] = None):
        _init_ast(self, pool, 0, 0)
        self.name = _copy_str(pool, name)
        self.args = args
        self.decorator_list = decorator_list
        self.returns = returns
        self.type_params = type_params
        if is_async:
            self.flags = FLAG_IS_ASYNC
        else:
            self.flags = 0
        _set_parent_list(decorator_list, self)

    def kind(self) -> int:
        return ASTKind.FunctionDef

    def type_name(self) -> str:
        return "FunctionDef"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "FunctionDef(name='")
        pos = _emit_str(buf, size, pos, self.name)
        pos = _emit(buf, size, pos, "', args=")
        if self.args is not None:
            pos = self.args.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ", body=")
        pos = _dump_list(self.children, buf, size, pos)
        pos = _emit(buf, size, pos, ", decorator_list=")
        pos = _dump_list(self.decorator_list, buf, size, pos)
        pos = _emit(buf, size, pos, ", returns=")
        if self.returns is not None:
            pos = self.returns.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# Expression Node
# ============================================================

class Expression(AST):
    """Expression(body: AST)"""
    body: rawptr[AST]

    def __new__(self, pool: rawptr[memhub.MemManager],
                body: rawptr[AST]):
        ptr: rawptr[Expression] = pool.alloc(Expression.__sizeof__())
        if ptr: string.memset(ptr, 0, Expression.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager],
                 body: rawptr[AST]):
        _init_ast(self, pool, 0, 0)
        self.body = body

    def kind(self) -> int:
        return ASTKind.Expression

    def type_name(self) -> str:
        return "Expression"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "Expression(body=")
        if self.body is not None:
            pos = self.body.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# Interactive Node
# ============================================================

class Interactive(AST):
    """Interactive(body: AST)"""
    body: rawptr[AST]

    def __new__(self, pool: rawptr[memhub.MemManager],
                body: rawptr[AST]):
        ptr: rawptr[Interactive] = pool.alloc(Interactive.__sizeof__())
        if ptr: string.memset(ptr, 0, Interactive.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager],
                 body: rawptr[AST]):
        _init_ast(self, pool, 0, 0)
        self.body = body

    def kind(self) -> int:
        return ASTKind.Interactive

    def type_name(self) -> str:
        return "Interactive"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "Interactive(body=")
        if self.body is not None:
            pos = self.body.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# FunctionType Node
# ============================================================

class FunctionType(AST):
    """FunctionType(argtypes: list[rawptr[AST]], returns: AST)"""
    argtypes: rawptr[list[rawptr[AST]]]
    returns:  rawptr[AST]

    def __new__(self, pool: rawptr[memhub.MemManager],
                argtypes: rawptr[list[rawptr[AST]]],
                returns: rawptr[AST]):
        ptr: rawptr[FunctionType] = pool.alloc(FunctionType.__sizeof__())
        if ptr: string.memset(ptr, 0, FunctionType.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager],
                 argtypes: rawptr[list[rawptr[AST]]],
                 returns: rawptr[AST]):
        _init_ast(self, pool, 0, 0)
        self.argtypes = argtypes
        self.returns = returns

    def kind(self) -> int:
        return ASTKind.FunctionType

    def type_name(self) -> str:
        return "FunctionType"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "FunctionType(argtypes=")
        pos = _dump_list(self.argtypes, buf, size, pos)
        pos = _emit(buf, size, pos, ", returns=")
        if self.returns is not None:
            pos = self.returns.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# ClassDef Node
# ============================================================

class ClassDef(Stmt):
    """ClassDef(name: str, bases: list[rawptr[AST]], keywords: list[rawptr[AST]],
                decorator_list: list[rawptr[AST]], type_params: rawptr[list[str]])

    type_params: generic type-parameter name list (the [T] in PEP 695 class list[T]:),
                 None means a non-generic class."""
    name:            str
    bases:           rawptr[list[rawptr[AST]]]
    keywords:        rawptr[list[rawptr[AST]]]
    decorator_list:  rawptr[list[rawptr[AST]]]
    type_params:     rawptr[list[str]]

    def __new__(self, pool: rawptr[memhub.MemManager],
                name: str,
                bases: rawptr[list[rawptr[AST]]],
                keywords: rawptr[list[rawptr[AST]]],
                decorator_list: rawptr[list[rawptr[AST]]],
                type_params: rawptr[list[str]] = None):
        ptr: rawptr[ClassDef] = pool.alloc(ClassDef.__sizeof__())
        if ptr: string.memset(ptr, 0, ClassDef.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager],
                 name: str,
                 bases: rawptr[list[rawptr[AST]]],
                 keywords: rawptr[list[rawptr[AST]]],
                 decorator_list: rawptr[list[rawptr[AST]]],
                 type_params: rawptr[list[str]] = None):
        _init_ast(self, pool, 0, 0)
        self.name = _copy_str(pool, name)
        self.bases = bases
        self.keywords = keywords
        self.decorator_list = decorator_list
        self.type_params = type_params
        _set_parent_list(decorator_list, self)

    def kind(self) -> int:
        return ASTKind.ClassDef

    def type_name(self) -> str:
        return "ClassDef"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "ClassDef(name='")
        pos = _emit_str(buf, size, pos, self.name)
        pos = _emit(buf, size, pos, "', bases=")
        pos = _dump_list(self.bases, buf, size, pos)
        pos = _emit(buf, size, pos, ", keywords=")
        pos = _dump_list(self.keywords, buf, size, pos)
        pos = _emit(buf, size, pos, ", body=")
        pos = _dump_list(self.children, buf, size, pos)
        pos = _emit(buf, size, pos, ", decorator_list=")
        pos = _dump_list(self.decorator_list, buf, size, pos)
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# Delete Node
# ============================================================

class Delete(Stmt):
    """Delete(targets: list[rawptr[AST]])"""
    targets: rawptr[list[rawptr[AST]]]

    def __new__(self, pool: rawptr[memhub.MemManager],
                targets: rawptr[list[rawptr[AST]]]):
        ptr: rawptr[Delete] = pool.alloc(Delete.__sizeof__())
        if ptr: string.memset(ptr, 0, Delete.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager],
                 targets: rawptr[list[rawptr[AST]]]):
        _init_ast(self, pool, 0, 0)
        self.targets = targets
        _set_parent_list(targets, self)

    def kind(self) -> int:
        return ASTKind.Delete

    def type_name(self) -> str:
        return "Delete"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "Delete(targets=")
        pos = _dump_list(self.targets, buf, size, pos)
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# AugAssign Node
# ============================================================

class AugAssign(Stmt):
    """AugAssign(target: AST, op: CInt, value: AST)"""
    target: rawptr[AST]
    op:     int
    value:  rawptr[AST]

    def __new__(self, pool: rawptr[memhub.MemManager],
                target: rawptr[AST], op: int, value: rawptr[AST]):
        ptr: rawptr[AugAssign] = pool.alloc(AugAssign.__sizeof__())
        if ptr: string.memset(ptr, 0, AugAssign.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager],
                 target: rawptr[AST], op: int, value: rawptr[AST]):
        _init_ast(self, pool, 0, 0)
        self.target = target
        self.op = op
        self.value = value

    def kind(self) -> int:
        return ASTKind.AugAssign

    def type_name(self) -> str:
        return "AugAssign"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "AugAssign(target=")
        if self.target is not None:
            pos = self.target.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ", op=")
        pos = _emit(buf, size, pos, _op_name(self.op))
        pos = _emit(buf, size, pos, ", value=")
        if self.value is not None:
            pos = self.value.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# AnnAssign Node
# ============================================================

class AnnAssign(Stmt):
    """AnnAssign(target: AST, annotation: AST, value: AST, simple: CInt)"""
    target:     rawptr[AST]
    annotation: rawptr[AST]
    value:      rawptr[AST]
    simple:     int

    def __new__(self, pool: rawptr[memhub.MemManager],
                target: rawptr[AST], annotation: rawptr[AST],
                value: rawptr[AST], simple: int):
        ptr: rawptr[AnnAssign] = pool.alloc(AnnAssign.__sizeof__())
        if ptr: string.memset(ptr, 0, AnnAssign.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager],
                 target: rawptr[AST], annotation: rawptr[AST],
                 value: rawptr[AST], simple: int):
        _init_ast(self, pool, 0, 0)
        self.target = target
        self.annotation = annotation
        self.value = value
        self.simple = simple

    def kind(self) -> int:
        return ASTKind.AnnAssign

    def type_name(self) -> str:
        return "AnnAssign"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "AnnAssign(target=")
        if self.target is not None:
            pos = self.target.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ", annotation=")
        if self.annotation is not None:
            pos = self.annotation.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ", value=")
        if self.value is not None:
            pos = self.value.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ", simple=")
        pos = _emit_int(buf, size, pos, int64(self.simple))
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# With Node
# ============================================================

class With(Stmt):
    """With(items: list[rawptr[AST]], is_async: CInt)"""
    items: rawptr[list[rawptr[AST]]]
    flags: int

    def __new__(self, pool: rawptr[memhub.MemManager],
                items: rawptr[list[rawptr[AST]]],
                is_async: int):
        ptr: rawptr[With] = pool.alloc(With.__sizeof__())
        if ptr: string.memset(ptr, 0, With.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager],
                 items: rawptr[list[rawptr[AST]]],
                 is_async: int):
        _init_ast(self, pool, 0, 0)
        self.items = items
        if is_async:
            self.flags = FLAG_IS_ASYNC
        else:
            self.flags = 0
        _set_parent_list(items, self)

    def kind(self) -> int:
        return ASTKind.With

    def type_name(self) -> str:
        return "With"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "With(items=")
        pos = _dump_list(self.items, buf, size, pos)
        pos = _emit(buf, size, pos, ", body=")
        pos = _dump_list(self.children, buf, size, pos)
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# Raise Node
# ============================================================

class Raise(Stmt):
    """Raise(exc: AST, cause: AST)"""
    exc:   rawptr[AST]
    cause: rawptr[AST]

    def __new__(self, pool: rawptr[memhub.MemManager],
                exc: rawptr[AST], cause: rawptr[AST]):
        ptr: rawptr[Raise] = pool.alloc(Raise.__sizeof__())
        if ptr: string.memset(ptr, 0, Raise.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager],
                 exc: rawptr[AST], cause: rawptr[AST]):
        _init_ast(self, pool, 0, 0)
        self.exc = exc
        self.cause = cause

    def kind(self) -> int:
        return ASTKind.Raise

    def type_name(self) -> str:
        return "Raise"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "Raise(exc=")
        if self.exc is not None:
            pos = self.exc.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ", cause=")
        if self.cause is not None:
            pos = self.cause.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# Try Node
# ============================================================

class Try(Stmt):
    """Try(handlers: list[rawptr[AST]],
          orelse: list[rawptr[AST]], finalbody: list[rawptr[AST]])"""
    handlers:  rawptr[list[rawptr[AST]]]
    orelse:    rawptr[list[rawptr[AST]]]
    finalbody: rawptr[list[rawptr[AST]]]

    def __new__(self, pool: rawptr[memhub.MemManager],
                handlers: rawptr[list[rawptr[AST]]],
                orelse: rawptr[list[rawptr[AST]]],
                finalbody: rawptr[list[rawptr[AST]]]):
        ptr: rawptr[Try] = pool.alloc(Try.__sizeof__())
        if ptr: string.memset(ptr, 0, Try.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager],
                 handlers: rawptr[list[rawptr[AST]]],
                 orelse: rawptr[list[rawptr[AST]]],
                 finalbody: rawptr[list[rawptr[AST]]]):
        _init_ast(self, pool, 0, 0)
        self.handlers = handlers
        self.orelse = orelse
        self.finalbody = finalbody
        _set_parent_list(handlers, self)
        _set_parent_list(orelse, self)
        _set_parent_list(finalbody, self)

    def kind(self) -> int:
        return ASTKind.Try

    def type_name(self) -> str:
        return "Try"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "Try(body=")
        pos = _dump_list(self.children, buf, size, pos)
        pos = _emit(buf, size, pos, ", handlers=")
        pos = _dump_list(self.handlers, buf, size, pos)
        pos = _emit(buf, size, pos, ", orelse=")
        pos = _dump_list(self.orelse, buf, size, pos)
        pos = _emit(buf, size, pos, ", finalbody=")
        pos = _dump_list(self.finalbody, buf, size, pos)
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# Assert Node
# ============================================================

class Assert(Stmt):
    """Assert(test: AST, msg: AST)"""
    test: rawptr[AST]
    msg:  rawptr[AST]

    def __new__(self, pool: rawptr[memhub.MemManager],
                test: rawptr[AST], msg: rawptr[AST]):
        ptr: rawptr[Assert] = pool.alloc(Assert.__sizeof__())
        if ptr: string.memset(ptr, 0, Assert.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager],
                 test: rawptr[AST], msg: rawptr[AST]):
        _init_ast(self, pool, 0, 0)
        self.test = test
        self.msg = msg

    def kind(self) -> int:
        return ASTKind.Assert

    def type_name(self) -> str:
        return "Assert"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "Assert(test=")
        if self.test is not None:
            pos = self.test.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ", msg=")
        if self.msg is not None:
            pos = self.msg.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# Global Node
# ============================================================

class Global(Stmt):
    """Global(names: list[rawptr[AST]])"""
    names: rawptr[list[rawptr[AST]]]

    def __new__(self, pool: rawptr[memhub.MemManager],
                names: rawptr[list[rawptr[AST]]]):
        ptr: rawptr[Global] = pool.alloc(Global.__sizeof__())
        if ptr: string.memset(ptr, 0, Global.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager],
                 names: rawptr[list[rawptr[AST]]]):
        _init_ast(self, pool, 0, 0)
        self.names = names
        _set_parent_list(names, self)

    def kind(self) -> int:
        return ASTKind.Global

    def type_name(self) -> str:
        return "Global"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "Global(names=")
        pos = _dump_list(self.names, buf, size, pos)
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# Nonlocal Node
# ============================================================

class Nonlocal(Stmt):
    """Nonlocal(names: list[rawptr[AST]])"""
    names: rawptr[list[rawptr[AST]]]

    def __new__(self, pool: rawptr[memhub.MemManager],
                names: rawptr[list[rawptr[AST]]]):
        ptr: rawptr[Nonlocal] = pool.alloc(Nonlocal.__sizeof__())
        if ptr: string.memset(ptr, 0, Nonlocal.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager],
                 names: rawptr[list[rawptr[AST]]]):
        _init_ast(self, pool, 0, 0)
        self.names = names
        _set_parent_list(names, self)

    def kind(self) -> int:
        return ASTKind.Nonlocal

    def type_name(self) -> str:
        return "Nonlocal"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "Nonlocal(names=")
        pos = _dump_list(self.names, buf, size, pos)
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# Pass Node
# ============================================================

class Pass(Stmt):
    """Pass()"""

    def __new__(self, pool: rawptr[memhub.MemManager]):
        ptr: rawptr[Pass] = pool.alloc(Pass.__sizeof__())
        if ptr: string.memset(ptr, 0, Pass.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager]):
        _init_ast(self, pool, 0, 0)

    def kind(self) -> int:
        return ASTKind.Pass

    def type_name(self) -> str:
        return "Pass"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "Pass()")
        return pos


# ============================================================
# Break Node
# ============================================================

class Break(Stmt):
    """Break()"""

    def __new__(self, pool: rawptr[memhub.MemManager]):
        ptr: rawptr[Break] = pool.alloc(Break.__sizeof__())
        if ptr: string.memset(ptr, 0, Break.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager]):
        _init_ast(self, pool, 0, 0)

    def kind(self) -> int:
        return ASTKind.Break

    def type_name(self) -> str:
        return "Break"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "Break()")
        return pos


# ============================================================
# Continue Node
# ============================================================

class Continue(Stmt):
    """Continue()"""

    def __new__(self, pool: rawptr[memhub.MemManager]):
        ptr: rawptr[Continue] = pool.alloc(Continue.__sizeof__())
        if ptr: string.memset(ptr, 0, Continue.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager]):
        _init_ast(self, pool, 0, 0)

    def kind(self) -> int:
        return ASTKind.Continue

    def type_name(self) -> str:
        return "Continue"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "Continue()")
        return pos


# ============================================================
# FallThrough Node (keyword `fallthrough`, legal only inside a switch case body)
# ============================================================

class FallThrough(Stmt):
    """FallThrough() - a switch case body does not auto-break, so it falls through to the next case"""

    def __new__(self, pool: rawptr[memhub.MemManager]):
        ptr: rawptr[FallThrough] = pool.alloc(FallThrough.__sizeof__())
        if ptr: string.memset(ptr, 0, FallThrough.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager]):
        _init_ast(self, pool, 0, 0)

    def kind(self) -> int:
        return ASTKind.FallThrough

    def type_name(self) -> str:
        return "FallThrough"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "FallThrough()")
        return pos


# ============================================================
# Import Node
# ============================================================

class Import(Stmt):
    """Import(names: list[rawptr[AST]])"""
    names: rawptr[list[rawptr[AST]]]

    def __new__(self, pool: rawptr[memhub.MemManager],
                names: rawptr[list[rawptr[AST]]]):
        ptr: rawptr[Import] = pool.alloc(Import.__sizeof__())
        if ptr: string.memset(ptr, 0, Import.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager],
                 names: rawptr[list[rawptr[AST]]]):
        _init_ast(self, pool, 0, 0)
        self.names = names
        _set_parent_list(names, self)

    def kind(self) -> int:
        return ASTKind.Import

    def type_name(self) -> str:
        return "Import"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "Import(names=")
        pos = _dump_list(self.names, buf, size, pos)
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# ImportFrom Node
# ============================================================

class ImportFrom(Stmt):
    """ImportFrom(module: str, names: list[rawptr[AST]], level: CInt)"""
    module: str
    names:  rawptr[list[rawptr[AST]]]
    level:  int

    def __new__(self, pool: rawptr[memhub.MemManager],
                module: str,
                names: rawptr[list[rawptr[AST]]],
                level: int):
        ptr: rawptr[ImportFrom] = pool.alloc(ImportFrom.__sizeof__())
        if ptr: string.memset(ptr, 0, ImportFrom.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager],
                 module: str,
                 names: rawptr[list[rawptr[AST]]],
                 level: int):
        _init_ast(self, pool, 0, 0)
        self.module = _copy_str(pool, module)
        self.names = names
        self.level = level
        _set_parent_list(names, self)

    def kind(self) -> int:
        return ASTKind.ImportFrom

    def type_name(self) -> str:
        return "ImportFrom"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "ImportFrom(module='")
        pos = _emit_str(buf, size, pos, self.module)
        pos = _emit(buf, size, pos, "', names=")
        pos = _dump_list(self.names, buf, size, pos)
        pos = _emit(buf, size, pos, ", level=")
        pos = _emit_int(buf, size, pos, int64(self.level))
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# Match Node
# ============================================================

class Match(Stmt):
    """Match(subject: AST, cases: list[rawptr[AST]], is_switch: int)

    is_switch=1: from `switch <expr>:` sugar (see _parse_switch), C semantics (no fall-through without
    `fallthrough`). is_switch=0: real `match`, fallthrough is completely forbidden (fail-fast).
    """
    subject:   rawptr[AST]
    cases:     rawptr[list[rawptr[AST]]]
    is_switch: int

    def __new__(self, pool: rawptr[memhub.MemManager],
                subject: rawptr[AST],
                cases: rawptr[list[rawptr[AST]]],
                is_switch: int):
        ptr: rawptr[Match] = pool.alloc(Match.__sizeof__())
        if ptr: string.memset(ptr, 0, Match.__sizeof__())
        return ptr

    def __init__(self, pool: rawptr[memhub.MemManager],
                 subject: rawptr[AST],
                 cases: rawptr[list[rawptr[AST]]],
                 is_switch: int):
        _init_ast(self, pool, 0, 0)
        self.subject = subject
        self.cases = cases
        self.is_switch = is_switch
        _set_parent_list(cases, self)

    def kind(self) -> int:
        return ASTKind.Match

    def type_name(self) -> str:
        return "Match"

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "Match(subject=")
        if self.subject is not None:
            pos = self.subject.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ", cases=")
        pos = _dump_list(self.cases, buf, size, pos)
        pos = _emit(buf, size, pos, ", is_switch=")
        pos = _emit_int(buf, size, pos, int64(self.is_switch))
        pos = _emit(buf, size, pos, ")")
        return pos