from stdint import *
import memhub
import string
from .base import (
    AST, ExprNode, ASTKind, ASTCtx, OpKind,
    _init_ast, _copy_str, _set_parent_list,
    _emit, _emit_str, _emit_int, _dump_list, _dump_op_list, _op_name,
    CONST_INT, CONST_FLOAT, CONST_STR, CONST_BOOL, CONST_NONE, CONST_CHAR
)


# ============================================================
# Name node
# ============================================================

class Name(ExprNode):
    """Name(id: str, ctx: ASTCtx)"""
    id:  str
    ctx: int

    def __new__(self, pool: memhub.MemManager*, id: str, ctx: int):
        ptr: Name* = pool.alloc(Name.__sizeof__())
        if ptr: string.memset(ptr, 0, Name.__sizeof__())
        return ptr

    def __init__(self, pool: memhub.MemManager*, id: str, ctx: int):
        _init_ast(self, pool, 0, 0)
        self.id = _copy_str(pool, id)
        self.ctx = ctx

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

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

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "Name(id='")
        pos = _emit_str(buf, size, pos, self.id)
        pos = _emit(buf, size, pos, "', ctx=")
        if self.ctx == ASTCtx.Load:
            pos = _emit(buf, size, pos, "Load")
        elif self.ctx == ASTCtx.Store:
            pos = _emit(buf, size, pos, "Store")
        else:
            pos = _emit(buf, size, pos, "Del")
        pos = _emit(buf, size, pos, ")")
        return pos


def name_get_id(node: Name*) -> str:
    """Get Name.id field (cross-module accessor; guards against stub field-access pitfalls)"""
    if node is None: return None
    return node.id


def constant_get_str_val(node: Constant*) -> str:
    """Get Constant.str_val field (cross-module accessor)"""
    if node is None: return None
    return node.str_val


def binop_get_left(node: BinOp*) -> AST*:
    """Get BinOp.left field (cross-module accessor)"""
    if node is None: return None
    return node.left


def binop_get_right(node: BinOp*) -> AST*:
    """Get BinOp.right field (cross-module accessor)"""
    if node is None: return None
    return node.right


# ============================================================
# Constant nodes (subtype marked by const_kind)
# ============================================================

class Constant(ExprNode):
    """Constant(int_val/float_val/str_val, const_kind)"""
    int_val:    int64
    float_val:  double
    str_val:    str
    const_kind: int
    # 显式整型宽度后缀（_int<N>/_uint<N>）：int_width>0 = 声明宽度，0 = 未指定；
    # int_unsigned=1 表示 uint 形式。追加在末尾，保持既有字段偏移不变（经 __sizeof__ 分配并 memset）。
    int_width:  int
    int_unsigned: int

    def __new__(self, pool: memhub.MemManager*,
                const_kind: int, int_val: int64,
                float_val: double, str_val: str,
                lineno: int, col: int,
                int_width: int = 0, int_unsigned: int = 0):
        ptr: Constant* = pool.alloc(Constant.__sizeof__())
        if ptr:
            string.memset(ptr, 0, Constant.__sizeof__())
        return ptr

    def __init__(self, pool: memhub.MemManager*,
                 const_kind: int, int_val: int64,
                 float_val: double, str_val: str,
                 lineno: int, col: int,
                 int_width: int = 0, int_unsigned: int = 0):
        _init_ast(self, pool, lineno, col)
        self.const_kind = const_kind
        self.int_val = int_val
        self.float_val = float_val
        self.int_width = int_width
        self.int_unsigned = int_unsigned
        if str_val is not None:
            self.str_val = _copy_str(pool, str_val)
        else:
            self.str_val = None

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

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

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "Constant(value=")
        if self.const_kind == CONST_INT:
            pos = _emit_int(buf, size, pos, self.int_val)
        elif self.const_kind == CONST_FLOAT:
            pos = _emit(buf, size, pos, "<float>")
        elif self.const_kind == CONST_STR:
            pos = _emit(buf, size, pos, "'")
            if self.str_val is not None:
                pos = _emit_str(buf, size, pos, self.str_val)
            else:
                pos = _emit(buf, size, pos, "(null)")
            pos = _emit(buf, size, pos, "'")
        elif self.const_kind == CONST_CHAR:
            # Single character → display as character ASCII value
            pos = _emit(buf, size, pos, "char(")
            pos = _emit_int(buf, size, pos, self.int_val)
            pos = _emit(buf, size, pos, ")")
        elif self.const_kind == CONST_BOOL:
            if self.int_val != 0:
                pos = _emit(buf, size, pos, "True")
            else:
                pos = _emit(buf, size, pos, "False")
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# BinOp Node
# ============================================================

class BinOp(ExprNode):
    """BinOp(left: AST, op: OpKind, right: AST)"""
    left:  AST*
    op:    int
    right: AST*

    def __new__(self, pool: memhub.MemManager*,
                left: AST*, op: int, right: AST*):
        ptr: BinOp* = pool.alloc(BinOp.__sizeof__())
        if ptr: string.memset(ptr, 0, BinOp.__sizeof__())
        return ptr

    def __init__(self, pool: memhub.MemManager*,
                 left: AST*, op: int, right: AST*):
        _init_ast(self, pool, 0, 0)
        self.left = left
        self.op = op
        self.right = right

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

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

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "BinOp(left=")
        if self.left is not None:
            pos = self.left.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, ", right=")
        if self.right is not None:
            pos = self.right.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# UnaryOp Node
# ============================================================

class UnaryOp(ExprNode):
    """UnaryOp(op: OpKind, operand: AST)"""
    op:      int
    operand: AST*

    def __new__(self, pool: memhub.MemManager*,
                op: int, operand: AST*):
        ptr: UnaryOp* = pool.alloc(UnaryOp.__sizeof__())
        if ptr: string.memset(ptr, 0, UnaryOp.__sizeof__())
        return ptr

    def __init__(self, pool: memhub.MemManager*,
                 op: int, operand: AST*):
        _init_ast(self, pool, 0, 0)
        self.op = op
        self.operand = operand

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

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

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


# ============================================================
# Compare Node
# ============================================================

class Compare(ExprNode):
    """Compare(left: AST, ops: list[CInt], comparators: list[AST | CPtr])"""
    left:        AST*
    ops:         t.CPtr
    comparators: list[AST*]*

    def __new__(self, pool: memhub.MemManager*,
                left: AST*,
                ops: t.CPtr,
                comparators: list[AST*]*):
        ptr: Compare* = pool.alloc(Compare.__sizeof__())
        if ptr: string.memset(ptr, 0, Compare.__sizeof__())
        return ptr

    def __init__(self, pool: memhub.MemManager*,
                 left: AST*,
                 ops: t.CPtr,
                 comparators: list[AST*]*):
        _init_ast(self, pool, 0, 0)
        self.left = left
        self.ops = ops
        self.comparators = comparators
        _set_parent_list(comparators, self)

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

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

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "Compare(left=")
        if self.left is not None:
            pos = self.left.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ", ops=")
        pos = _dump_op_list(self.ops, buf, size, pos)
        pos = _emit(buf, size, pos, ", comparators=")
        pos = _dump_list(self.comparators, buf, size, pos)
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# Call Node
# ============================================================

class Call(ExprNode):
    """Call(func: AST, args: list[AST | CPtr], keywords: list[AST | CPtr])"""
    func:     AST*
    args:     list[AST*]*
    keywords: list[AST*]*
    # Value-position `volatile f()` / `volatile S()` prefix marker (see _IsVolatileCallPrefix):
    # 1 = result/temp slot accessed volatile (struct writes too). Appended last: offsets unchanged.
    IsVolatile: int

    def __new__(self, pool: memhub.MemManager*,
                func: AST*,
                args: list[AST*]*,
                keywords: list[AST*]*):
        ptr: Call* = pool.alloc(Call.__sizeof__())
        if ptr: string.memset(ptr, 0, Call.__sizeof__())
        return ptr

    def __init__(self, pool: memhub.MemManager*,
                 func: AST*,
                 args: list[AST*]*,
                 keywords: list[AST*]*):
        _init_ast(self, pool, 0, 0)
        self.func = func
        self.args = args
        self.keywords = keywords
        self.IsVolatile = 0
        _set_parent_list(args, self)
        _set_parent_list(keywords, self)

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

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

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


# ============================================================
# New Node（M2.4：`new` 描述符分配）
# ============================================================
# 两条正交轴，各取其一；顺序无关；重复/冲突在解析期即报错。
# 来源 SourceKind：缺省 = heap（D3）
define NEW_SRC_DEFAULT = 0
define NEW_SRC_STACK   = 1
define NEW_SRC_HEAP    = 2
define NEW_SRC_MEMGR   = 3
# 生命期 LifeKind：缺省由来源决定（stack→slife，heap/memgr→hlife）
define NEW_LIFE_DEFAULT = 0
define NEW_LIFE_SLIFE   = 1
define NEW_LIFE_HLIFE   = 2


class New(ExprNode):
    """New(Source: CInt, Life: CInt, memgr: AST | CPtr, func: AST, args: list[AST | CPtr])"""
    Source:  int         # SourceKind（NEW_SRC_*）
    Life:    int         # LifeKind（NEW_LIFE_*）
    memgr:   AST*        # `memgr(x)` 的 x；无 memgr 描述符时为 None
    func:    AST*        # 被构造的类型/可调用（`new ... T(args)` 里的 T）
    args:    list[AST*]*

    def __new__(self, pool: memhub.MemManager*,
                Source: int,
                Life: int,
                memgr: AST*,
                func: AST*,
                args: list[AST*]*):
        ptr: New* = pool.alloc(New.__sizeof__())
        if ptr: string.memset(ptr, 0, New.__sizeof__())
        return ptr

    def __init__(self, pool: memhub.MemManager*,
                 Source: int,
                 Life: int,
                 memgr: AST*,
                 func: AST*,
                 args: list[AST*]*):
        _init_ast(self, pool, 0, 0)
        self.Source = Source
        self.Life = Life
        self.memgr = memgr
        self.func = func
        self.args = args
        _set_parent_list(args, self)

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

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

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "New(")
        if self.memgr is not None:
            pos = _emit(buf, size, pos, ", memgr=")
            pos = self.memgr.dump(buf, size, pos)
        pos = _emit(buf, size, pos, ", func=")
        if self.func is not None:
            pos = self.func.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ", args=")
        pos = _dump_list(self.args, buf, size, pos)
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# BoolOp Node
# ============================================================

class BoolOp(ExprNode):
    """BoolOp(op: CInt, values: list[AST | CPtr])"""
    op:     int
    values: list[AST*]*

    def __new__(self, pool: memhub.MemManager*,
                op: int,
                values: list[AST*]*):
        ptr: BoolOp* = pool.alloc(BoolOp.__sizeof__())
        if ptr: string.memset(ptr, 0, BoolOp.__sizeof__())
        return ptr

    def __init__(self, pool: memhub.MemManager*,
                 op: int,
                 values: list[AST*]*):
        _init_ast(self, pool, 0, 0)
        self.op = op
        self.values = values
        _set_parent_list(values, self)

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

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

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "BoolOp(op=")
        pos = _emit(buf, size, pos, _op_name(self.op))
        pos = _emit(buf, size, pos, ", values=")
        pos = _dump_list(self.values, buf, size, pos)
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# Lambda Node
# ============================================================

class Lambda(ExprNode):
    """Lambda(args: AST, body: AST)"""
    args: AST*
    body: AST*

    def __new__(self, pool: memhub.MemManager*,
                args: AST*, body: AST*):
        ptr: Lambda* = pool.alloc(Lambda.__sizeof__())
        if ptr: string.memset(ptr, 0, Lambda.__sizeof__())
        return ptr

    def __init__(self, pool: memhub.MemManager*,
                 args: AST*, body: AST*):
        _init_ast(self, pool, 0, 0)
        self.args = args
        self.body = body

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

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

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "Lambda(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=")
        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


# ============================================================
# IfExp Node
# ============================================================

class IfExp(ExprNode):
    """IfExp(test: AST, body: AST, orelse: AST)"""
    test:   AST*
    body:   AST*
    orelse: AST*

    def __new__(self, pool: memhub.MemManager*,
                test: AST*, body: AST*,
                orelse: AST*):
        ptr: IfExp* = pool.alloc(IfExp.__sizeof__())
        if ptr: string.memset(ptr, 0, IfExp.__sizeof__())
        return ptr

    def __init__(self, pool: memhub.MemManager*,
                 test: AST*, body: AST*,
                 orelse: AST*):
        _init_ast(self, pool, 0, 0)
        self.test = test
        self.body = body
        self.orelse = orelse

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

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

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "IfExp(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=")
        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, ", orelse=")
        if self.orelse is not None:
            pos = self.orelse.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# Dict Node
# ============================================================

class Dict(ExprNode):
    """Dict(keys: list[AST | CPtr], values: list[AST | CPtr])"""
    keys:   list[AST*]*
    values: list[AST*]*

    def __new__(self, pool: memhub.MemManager*,
                keys: list[AST*]*,
                values: list[AST*]*):
        ptr: Dict* = pool.alloc(Dict.__sizeof__())
        if ptr: string.memset(ptr, 0, Dict.__sizeof__())
        return ptr

    def __init__(self, pool: memhub.MemManager*,
                 keys: list[AST*]*,
                 values: list[AST*]*):
        _init_ast(self, pool, 0, 0)
        self.keys = keys
        self.values = values
        _set_parent_list(keys, self)
        _set_parent_list(values, self)

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

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

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


# ============================================================
# Set Node
# ============================================================

class Set(ExprNode):
    """Set(elts: list[AST | CPtr])"""
    elts: list[AST*]*

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

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

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

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

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


# ============================================================
# ListComp Node
# ============================================================

class ListComp(ExprNode):
    """ListComp(elt: AST, generators: list[AST | CPtr])"""
    elt:        AST*
    generators: list[AST*]*

    def __new__(self, pool: memhub.MemManager*,
                elt: AST*,
                generators: list[AST*]*):
        ptr: ListComp* = pool.alloc(ListComp.__sizeof__())
        if ptr: string.memset(ptr, 0, ListComp.__sizeof__())
        return ptr

    def __init__(self, pool: memhub.MemManager*,
                 elt: AST*,
                 generators: list[AST*]*):
        _init_ast(self, pool, 0, 0)
        self.elt = elt
        self.generators = generators
        _set_parent_list(generators, self)

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

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

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


# ============================================================
# SetComp Node
# ============================================================

class SetComp(ExprNode):
    """SetComp(elt: AST, generators: list[AST | CPtr])"""
    elt:        AST*
    generators: list[AST*]*

    def __new__(self, pool: memhub.MemManager*,
                elt: AST*,
                generators: list[AST*]*):
        ptr: SetComp* = pool.alloc(SetComp.__sizeof__())
        if ptr: string.memset(ptr, 0, SetComp.__sizeof__())
        return ptr

    def __init__(self, pool: memhub.MemManager*,
                 elt: AST*,
                 generators: list[AST*]*):
        _init_ast(self, pool, 0, 0)
        self.elt = elt
        self.generators = generators
        _set_parent_list(generators, self)

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

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

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


# ============================================================
# DictComp Node
# ============================================================

class DictComp(ExprNode):
    """DictComp(key: AST, value: AST, generators: list[AST | CPtr])"""
    key:        AST*
    value:      AST*
    generators: list[AST*]*

    def __new__(self, pool: memhub.MemManager*,
                key: AST*, value: AST*,
                generators: list[AST*]*):
        ptr: DictComp* = pool.alloc(DictComp.__sizeof__())
        if ptr: string.memset(ptr, 0, DictComp.__sizeof__())
        return ptr

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

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

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

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "DictComp(key=")
        if self.key is not None:
            pos = self.key.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, ", generators=")
        pos = _dump_list(self.generators, buf, size, pos)
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# GeneratorExp Node
# ============================================================

class GeneratorExp(ExprNode):
    """GeneratorExp(elt: AST, generators: list[AST | CPtr])"""
    elt:        AST*
    generators: list[AST*]*

    def __new__(self, pool: memhub.MemManager*,
                elt: AST*,
                generators: list[AST*]*):
        ptr: GeneratorExp* = pool.alloc(GeneratorExp.__sizeof__())
        if ptr: string.memset(ptr, 0, GeneratorExp.__sizeof__())
        return ptr

    def __init__(self, pool: memhub.MemManager*,
                 elt: AST*,
                 generators: list[AST*]*):
        _init_ast(self, pool, 0, 0)
        self.elt = elt
        self.generators = generators
        _set_parent_list(generators, self)

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

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

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


# ============================================================
# Await Node
# ============================================================

class Await(ExprNode):
    """Await(value: AST)"""
    value: AST*

    def __new__(self, pool: memhub.MemManager*, value: AST*):
        ptr: Await* = pool.alloc(Await.__sizeof__())
        if ptr: string.memset(ptr, 0, Await.__sizeof__())
        return ptr

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

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

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

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "Await(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


# ============================================================
# Yield Node
# ============================================================

class Yield(ExprNode):
    """Yield(value: AST)"""
    value: AST*

    def __new__(self, pool: memhub.MemManager*, value: AST*):
        ptr: Yield* = pool.alloc(Yield.__sizeof__())
        if ptr: string.memset(ptr, 0, Yield.__sizeof__())
        return ptr

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

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

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

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "Yield(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


# ============================================================
# YieldFrom Node
# ============================================================

class YieldFrom(ExprNode):
    """YieldFrom(value: AST)"""
    value: AST*

    def __new__(self, pool: memhub.MemManager*, value: AST*):
        ptr: YieldFrom* = pool.alloc(YieldFrom.__sizeof__())
        if ptr: string.memset(ptr, 0, YieldFrom.__sizeof__())
        return ptr

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

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

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

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "YieldFrom(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


# ============================================================
# FormattedValue Node
# ============================================================

class FormattedValue(ExprNode):
    """FormattedValue(value: AST, conversion: CInt, format_spec: AST)"""
    value:       AST*
    conversion:  int
    format_spec: AST*

    def __new__(self, pool: memhub.MemManager*,
                value: AST*, conversion: int,
                format_spec: AST*):
        ptr: FormattedValue* = pool.alloc(FormattedValue.__sizeof__())
        if ptr: string.memset(ptr, 0, FormattedValue.__sizeof__())
        return ptr

    def __init__(self, pool: memhub.MemManager*,
                 value: AST*, conversion: int,
                 format_spec: AST*):
        _init_ast(self, pool, 0, 0)
        self.value = value
        self.conversion = conversion
        self.format_spec = format_spec

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

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

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "FormattedValue(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, ", conversion=")
        pos = _emit_int(buf, size, pos, int64(self.conversion))
        pos = _emit(buf, size, pos, ", format_spec=")
        if self.format_spec is not None:
            pos = self.format_spec.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# JoinedStr Node
# ============================================================

class JoinedStr(ExprNode):
    """JoinedStr(values: list[AST | CPtr])"""
    values: list[AST*]*

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

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

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

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

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


# ============================================================
# Attribute Node
# ============================================================

class Attribute(ExprNode):
    """Attribute(value: AST, attr: str, ctx: CInt)"""
    value: AST*
    attr:  str
    ctx:   int

    def __new__(self, pool: memhub.MemManager*,
                value: AST*, attr: str, ctx: int):
        ptr: Attribute* = pool.alloc(Attribute.__sizeof__())
        if ptr: string.memset(ptr, 0, Attribute.__sizeof__())
        return ptr

    def __init__(self, pool: memhub.MemManager*,
                 value: AST*, attr: str, ctx: int):
        _init_ast(self, pool, 0, 0)
        self.value = value
        self.attr = _copy_str(pool, attr)
        self.ctx = ctx

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

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

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "Attribute(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, ", attr='")
        pos = _emit_str(buf, size, pos, self.attr)
        pos = _emit(buf, size, pos, "', ctx=")
        pos = _emit_int(buf, size, pos, int64(self.ctx))
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# Field accessors (guard against cross-module stub field-access pitfalls): other modules reading
# ast.Attribute fields directly may get a wrong stub GEP and crash, so they use these accessors.
# ============================================================
def attribute_get_value(node: Attribute*) -> AST*:
    """Get Attribute.value field (cross-module accessor)"""
    if node is None: return None
    return node.value


def attribute_get_attr(node: Attribute*) -> str:
    """Get Attribute.attr field (cross-module accessor)"""
    if node is None: return None
    return node.attr


# ============================================================
# Subscript Node
# ============================================================

class Subscript(ExprNode):
    """Subscript(value: AST, slice: AST, ctx: CInt)"""
    value: AST*
    slice: AST*
    ctx:   int

    def __new__(self, pool: memhub.MemManager*,
                value: AST*, slice: AST*, ctx: int):
        ptr: Subscript* = pool.alloc(Subscript.__sizeof__())
        if ptr: string.memset(ptr, 0, Subscript.__sizeof__())
        return ptr

    def __init__(self, pool: memhub.MemManager*,
                 value: AST*, slice: AST*, ctx: int):
        _init_ast(self, pool, 0, 0)
        self.value = value
        self.slice = slice
        self.ctx = ctx

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

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

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "Subscript(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, ", slice=")
        if self.slice is not None:
            pos = self.slice.dump(buf, size, pos)
        else:
            pos = _emit(buf, size, pos, "None")
        pos = _emit(buf, size, pos, ", ctx=")
        pos = _emit_int(buf, size, pos, int64(self.ctx))
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# Starred Node
# ============================================================

class Starred(ExprNode):
    """Starred(value: AST, ctx: CInt)"""
    value: AST*
    ctx:   int

    def __new__(self, pool: memhub.MemManager*,
                value: AST*, ctx: int):
        ptr: Starred* = pool.alloc(Starred.__sizeof__())
        if ptr: string.memset(ptr, 0, Starred.__sizeof__())
        return ptr

    def __init__(self, pool: memhub.MemManager*,
                 value: AST*, ctx: int):
        _init_ast(self, pool, 0, 0)
        self.value = value
        self.ctx = ctx

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

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

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "Starred(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, ", ctx=")
        pos = _emit_int(buf, size, pos, int64(self.ctx))
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# List Node
# ============================================================

class List(ExprNode):
    """List(elts: list[AST | CPtr], ctx: CInt)"""
    elts: list[AST*]*
    ctx:  int

    def __new__(self, pool: memhub.MemManager*,
                elts: list[AST*]*, ctx: int):
        ptr: List* = pool.alloc(List.__sizeof__())
        if ptr: string.memset(ptr, 0, List.__sizeof__())
        return ptr

    def __init__(self, pool: memhub.MemManager*,
                 elts: list[AST*]*, ctx: int):
        _init_ast(self, pool, 0, 0)
        self.elts = elts
        self.ctx = ctx
        _set_parent_list(elts, self)

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

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

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "List(elts=")
        pos = _dump_list(self.elts, buf, size, pos)
        pos = _emit(buf, size, pos, ", ctx=")
        pos = _emit_int(buf, size, pos, int64(self.ctx))
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# Tuple Node
# ============================================================

class Tuple(ExprNode):
    """Tuple(elts: list[AST | CPtr], ctx: CInt)"""
    elts: list[AST*]*
    ctx:  int

    def __new__(self, pool: memhub.MemManager*,
                elts: list[AST*]*, ctx: int):
        ptr: Tuple* = pool.alloc(Tuple.__sizeof__())
        if ptr: string.memset(ptr, 0, Tuple.__sizeof__())
        return ptr

    def __init__(self, pool: memhub.MemManager*,
                 elts: list[AST*]*, ctx: int):
        _init_ast(self, pool, 0, 0)
        self.elts = elts
        self.ctx = ctx
        _set_parent_list(elts, self)

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

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

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "Tuple(elts=")
        pos = _dump_list(self.elts, buf, size, pos)
        pos = _emit(buf, size, pos, ", ctx=")
        pos = _emit_int(buf, size, pos, int64(self.ctx))
        pos = _emit(buf, size, pos, ")")
        return pos


# ============================================================
# Slice Node
# ============================================================

class Slice(ExprNode):
    """Slice(lower: AST, upper: AST, step: AST)"""
    lower: AST*
    upper: AST*
    step:  AST*

    def __new__(self, pool: memhub.MemManager*,
                lower: AST*, upper: AST*,
                step: AST*):
        ptr: Slice* = pool.alloc(Slice.__sizeof__())
        if ptr: string.memset(ptr, 0, Slice.__sizeof__())
        return ptr

    def __init__(self, pool: memhub.MemManager*,
                 lower: AST*, upper: AST*,
                 step: AST*):
        _init_ast(self, pool, 0, 0)
        self.lower = lower
        self.upper = upper
        self.step = step

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

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

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


# ============================================================
# NamedExpr Node
# ============================================================

class NamedExpr(ExprNode):
    """NamedExpr(target: AST, value: AST)"""
    target: AST*
    value:  AST*

    def __new__(self, pool: memhub.MemManager*,
                target: AST*, value: AST*):
        ptr: NamedExpr* = pool.alloc(NamedExpr.__sizeof__())
        if ptr: string.memset(ptr, 0, NamedExpr.__sizeof__())
        return ptr

    def __init__(self, pool: memhub.MemManager*,
                 target: AST*, value: AST*):
        _init_ast(self, pool, 0, 0)
        self.target = target
        self.value = value

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

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

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "NamedExpr(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, ", 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


# ============================================================
# OpNode Node
# ============================================================

class OpNode(AST):
    """OpNode(op: CInt)"""
    op: int

    def __new__(self, pool: memhub.MemManager*, op: int):
        ptr: OpNode* = pool.alloc(OpNode.__sizeof__())
        if ptr: string.memset(ptr, 0, OpNode.__sizeof__())
        return ptr

    def __init__(self, pool: memhub.MemManager*, op: int):
        _init_ast(self, pool, 0, 0)
        self.op = op

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

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

    def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
        pos = _emit(buf, size, pos, "OpNode(op=")
        pos = _emit(buf, size, pos, _op_name(self.op))
        pos = _emit(buf, size, pos, ")")
        return pos