ViperC/App/lib/core/Handles/HandlesStruct.vp

import t, c
from stdint import *
import memhub
import string
import stdlib
import llvmlite
import stdio
import ast
import hashtable
import viperlib
import lib.core.VLogger as VLogger


# ============================================================
# HandlesStruct - 结构体类型注册和字段查找（P2-2 对象化后的委托层）
#
# 管理 class 定义的结构体类型信息:
# - 类名 → LLVM StructType
# - 字段名 → 字段索引和类型
#
# P2-2 对象化重构（wiki/14-oo-refactor.md）：
#   全部函数已迁移为 lib.core.Gen.StructGenMixin 的方法（全局状态迁入
#   gen 字段），本模块保留同名模块级函数作为"一行委托"：延迟 import
#   Gen 取全局单例（BuildPipeline/main 创建后 set_global_gen 注册），
#   再调用 gen 的对应方法。签名与旧函数完全一致，调用方零改动。
#
# FieldEntry/StructEntry 类型与常量保留在本模块（gen 字段类型引用）。
# ============================================================

STRUCT_MAX: t.CDefine = 512
# 字段槽位上限制（Generator 43 Mixin 展平 ~120 字段；2026-08-16 追加78：64
# 截断导致第 9+ 父类字段丢失 → __init__ 写 self.DiagStmtCount "属性写入失败"。
# 拆分重构使 Generator 父类数增至 43，FIELD_MAX 提至 256 防静默截断）
FIELD_MAX: t.CDefine = 256
FIELD_NAME_MAX: t.CDefine = 64
# 多继承（MRO）支持：单类最大父类数 / MRO 链最大长度（Generator 43 父类；
# PARENT_MAX=16 时 _collect_parents/set_parent_names 只收前 16 个 → 第 17+
# 父类字段丢失 → __init__ 写 self.DiagStmtCount "属性写入失败" 根因）
PARENT_MAX: t.CDefine = 64
MRO_MAX: t.CDefine = 64


# ============================================================
# FieldEntry - 字段信息条目
# ============================================================
@t.NoVTable
class FieldEntry:
    Name: str           # 字段名（字符串）
    Index: int                    # 字段在结构体中的索引
    Ty: llvmlite.LLVMType | t.CPtr   # 字段的 LLVM 类型
    DefaultVal: ast.AST | t.CPtr     # 默认值 AST 节点（None=无默认值）
    AnnotClassName: str    # 原始类型注解的类名（str 别名在结构体字段中触发编译器 bug，改用显式联合类型）


# ============================================================
# StructEntry - 结构体注册条目
# ============================================================
@t.NoVTable
class StructEntry:
    Name: str               # 类名
    Ty: llvmlite.LLVMType | t.CPtr       # LLVM StructType
    FieldCount: int                  # 字段数量
    Fields: FieldEntry | t.CPtr         # 字段数组（FIELD_MAX 个槽位）
    IsUnion: int                     # 1=联合体 / 0=普通结构体
    IsOOP: int                       # 1=OOP结构体（有方法） / 0=纯内存结构体
    HasInit: int                     # 1=有__init__方法 / 0=无
    HasNew: int                      # 1=有__new__方法 / 0=无
    HasVTable: int                   # 1=有虚表 / 0=无虚表
    IsNoVTable: int                  # 1=明确标记 @t.NoVTable / 0=未标记
    ParentName: str        # 父类名（None=无父类，多继承时为第一个父类，兼容旧调用）
    ParentNames: t.CSizeT | t.CPtr      # 多继承父类名数组（每元素 str 指针，ParentCount 个；stdlib 深拷贝）
    ParentCount: t.CInt                 # 父类数量（0=无父类，1=单继承，>1=多继承）
    VTableMethodCount: int           # 虚表中的方法数量
    VTableMethods: str     # 虚表方法名数组（每个方法名 str，VTableMethodCount 个）
    ModuleSha1: str        # 定义该类的模块 SHA1（None=无 SHA1）
    MethodsEmitted: int                 # 1=方法体已翻译 / 0=未译（Phase 1a mark_only 未译，Phase B 据此补译）


# ============================================================
# 全局 gen 单例（模块级镜像，同 HandlesType 模式）
#
# 由 BuildPipeline/main 在 gen 创建后调用 set_global_gen 注入。
# P2-2 委托函数用本地 _g_gen（cast 成 Generator 类型）调
# StructGenMixin 方法，避免函数体 import 包模块与 Generator
# 类/模块名歧义。
# ============================================================
_g_gen: t.CVoid | t.CPtr = None


def set_global_gen(gen: t.CVoid | t.CPtr) -> None:
    """注入全局 gen 单例（BuildPipeline/main 调用）"""
    global _g_gen
    _g_gen = gen


# ============================================================
# 委托函数：延迟 import Gen 取全局单例 → 调 gen 方法
# （gen 未注册时正常流程不会发生；有返回值函数返回默认值）
# ============================================================


def set_stdlib_alloc(flag: int):
    """设置 OOM 回收分配模式（委托到 gen.set_stdlib_alloc）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        g.set_stdlib_alloc(flag)


def get_stdlib_alloc() -> int:
    """读取 OOM 回收分配模式（委托到 gen.get_stdlib_alloc）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.get_stdlib_alloc()
    return 0


def reset_visible_structs(pool: memhub.MemBuddy | t.CPtr, strict: int):
    """重置可见性状态（每个文件翻译前调用，委托到 gen.reset_visible_structs）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        g.reset_visible_structs(pool, strict)


def add_visible_struct(pool: memhub.MemBuddy | t.CPtr, name: str):
    """添加可见结构体名（类定义时和 from-import 时调用，委托到 gen.add_visible_struct）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        g.add_visible_struct(pool, name)


def is_struct_visible(name: str) -> int:
    """检查结构体是否可见，返回 1=可见 / 0=不可见（委托到 gen.is_struct_visible）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.is_struct_visible(name)
    return 0


def init_struct_table(pool: memhub.MemBuddy | t.CPtr) -> int:
    """初始化结构体注册表，返回 1 成功（委托到 gen.init_struct_table）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.init_struct_table(pool)
    return 0


def _get_struct_entry(i: int) -> StructEntry | t.CPtr:
    """获取第 i 个结构体条目（委托到 gen._get_struct_entry）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g._get_struct_entry(i)
    return None


def _get_field_entry(struct_entry: StructEntry | t.CPtr, i: int) -> FieldEntry | t.CPtr:
    """获取结构体中第 i 个字段条目（委托到 gen._get_field_entry）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g._get_field_entry(struct_entry, i)
    return None


def register_struct(pool: memhub.MemBuddy | t.CPtr,
                    name: str,
                    struct_ty: llvmlite.LLVMType | t.CPtr,
                    sha1: str = None) -> StructEntry | t.CPtr:
    """注册结构体类型，返回 StructEntry 指针（委托到 gen.register_struct）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.register_struct(pool, name, struct_ty, sha1)
    return None


def set_struct_sha1(pool: memhub.MemBuddy | t.CPtr,
                    class_name: str, sha1: str) -> int:
    """设置结构体所属模块的 SHA1，返回 1=成功 / 0=失败（委托到 gen.set_struct_sha1）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.set_struct_sha1(pool, class_name, sha1)
    return 0


def get_struct_sha1(class_name: str) -> str:
    """获取结构体所属模块的 SHA1，返回 None=无 SHA1（委托到 gen.get_struct_sha1）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.get_struct_sha1(class_name)
    return None


def add_field(pool: memhub.MemBuddy | t.CPtr,
              struct_entry: StructEntry | t.CPtr,
              field_name: str,
              field_ty: llvmlite.LLVMType | t.CPtr,
              default_val: ast.AST | t.CPtr = None,
              annot_class_name: str = None) -> int:
    """向结构体添加字段，返回字段索引（-1 失败，委托到 gen.add_field）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.add_field(pool, struct_entry, field_name, field_ty,
                           default_val, annot_class_name)
    return 0


def get_struct_count() -> int:
    """返回当前已注册的结构体数量（委托到 gen.get_struct_count）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.get_struct_count()
    return 0


def reset_module_methods_emitted(sha1: str) -> int:
    """回滚指定模块注册类的 MethodsEmitted 标志（Phase A _deps_pending 重试
    前调用，防 MethodsEmitted 跨遍残留导致类方法缺失——追加87，委托到 gen.reset_module_methods_emitted）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.reset_module_methods_emitted(sha1)
    return 0


def find_struct(name: str) -> StructEntry | t.CPtr:
    """按类名查找结构体，返回 StructEntry 或 None（委托到 gen.find_struct）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.find_struct(name)
    return None


def find_struct_by_module(name: str, sha1: str) -> StructEntry | t.CPtr:
    """按类名 + SHA1 查找结构体，返回 StructEntry 或 None（委托到 gen.find_struct_by_module）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.find_struct_by_module(name, sha1)
    return None


def find_struct_by_type(struct_ty: llvmlite.LLVMType | t.CPtr) -> StructEntry | t.CPtr:
    """按类型指针查找结构体（指针值比较），返回 StructEntry 或 None（委托到 gen.find_struct_by_type）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.find_struct_by_type(struct_ty)
    return None


def lookup_field(struct_ty: llvmlite.LLVMType | t.CPtr,
                 field_name: str) -> FieldEntry | t.CPtr:
    """按结构体类型和字段名查找字段信息（委托到 gen.lookup_field）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.lookup_field(struct_ty, field_name)
    return None


def lookup_field_by_class(class_name: str,
                          field_name: str,
                          sha1: str = None) -> FieldEntry | t.CPtr:
    """按类名和字段名查找字段信息（委托到 gen.lookup_field_by_class）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.lookup_field_by_class(class_name, field_name, sha1)
    return None


def get_struct_type(class_name: str) -> llvmlite.LLVMType | t.CPtr:
    """按类名获取结构体的 LLVM 类型（委托到 gen.get_struct_type）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.get_struct_type(class_name)
    return None


def get_field_by_index(class_name: str,
                       idx: int) -> FieldEntry | t.CPtr:
    """按类名和字段索引获取字段信息（委托到 gen.get_field_by_index）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.get_field_by_index(class_name, idx)
    return None


def struct_has_defaults(class_name: str) -> int:
    """检查结构体是否有任何带默认值的字段，返回 1=有 / 0=无（委托到 gen.struct_has_defaults）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.struct_has_defaults(class_name)
    return 0


def get_struct_type_from_value(val: llvmlite.Value | t.CPtr) -> llvmlite.LLVMType | t.CPtr:
    """从 Value 的类型推断结构体类型（委托到 gen.get_struct_type_from_value）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.get_struct_type_from_value(val)
    return None


def mark_as_union(name: str) -> int:
    """标记已注册的结构体为联合体，返回 1=成功 / 0=失败（委托到 gen.mark_as_union）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.mark_as_union(name)
    return 0


def is_union_by_name(name: str) -> int:
    """按类名检查是否为联合体，返回 1=是 / 0=否（委托到 gen.is_union_by_name）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.is_union_by_name(name)
    return 0


def is_union_by_type(struct_ty: llvmlite.LLVMType | t.CPtr) -> int:
    """按类型指针检查是否为联合体，返回 1=是 / 0=否（委托到 gen.is_union_by_type）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.is_union_by_type(struct_ty)
    return 0


def mark_as_oop(name: str) -> int:
    """标记已注册的结构体为 OOP，返回 1=成功 / 0=失败（委托到 gen.mark_as_oop）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.mark_as_oop(name)
    return 0


def is_oop_by_name(name: str) -> int:
    """按类名检查是否为 OOP 结构体，返回 1=是 / 0=否（委托到 gen.is_oop_by_name）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.is_oop_by_name(name)
    return 0


def mark_has_init(name: str) -> int:
    """标记结构体拥有 __init__ 方法，返回 1=成功 / 0=失败（委托到 gen.mark_has_init）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.mark_has_init(name)
    return 0


def has_init_by_name(name: str) -> int:
    """按类名检查是否有 __init__ 方法，返回 1=有 / 0=无（委托到 gen.has_init_by_name）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.has_init_by_name(name)
    return 0


def mark_has_new(name: str) -> int:
    """标记结构体拥有 __new__ 方法，返回 1=成功 / 0=失败（委托到 gen.mark_has_new）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.mark_has_new(name)
    return 0


def has_new_by_name(name: str) -> int:
    """按类名检查是否有 __new__ 方法，返回 1=有 / 0=无（委托到 gen.has_new_by_name）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.has_new_by_name(name)
    return 0


def get_class_name_by_type(pool: memhub.MemBuddy | t.CPtr,
                           struct_ty: llvmlite.LLVMType | t.CPtr) -> str:
    """按类型指针查找类名，返回类名字符串或 None（委托到 gen.get_class_name_by_type）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.get_class_name_by_type(pool, struct_ty)
    return None


def _extract_struct_name(ty: llvmlite.LLVMType | t.CPtr) -> str:
    """从 LLVMType 提取 Struct 变体的 Name 字段，返回 None 非 Struct（委托到 gen._extract_struct_name）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g._extract_struct_name(ty)
    return None


def mark_has_vtable(name: str) -> int:
    """标记结构体拥有虚表，返回 1=成功 / 0=失败（委托到 gen.mark_has_vtable）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.mark_has_vtable(name)
    return 0


def has_vtable_by_name(name: str) -> int:
    """按类名检查是否有虚表，返回 1=有 / 0=无（委托到 gen.has_vtable_by_name）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.has_vtable_by_name(name)
    return 0


def mark_novtable(name: str) -> int:
    """标记结构体为 NoVTable，返回 1=成功 / 0=失败（委托到 gen.mark_novtable）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.mark_novtable(name)
    return 0


def is_novtable_by_name(name: str) -> int:
    """按类名检查是否为 NoVTable，返回 1=是 / 0=否（委托到 gen.is_novtable_by_name）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.is_novtable_by_name(name)
    return 0


def set_parent_name(name: str, parent_name: str) -> int:
    """设置结构体的父类名，返回 1=成功 / 0=失败（委托到 gen.set_parent_name）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.set_parent_name(name, parent_name)
    return 0


def set_parent_names(pool: memhub.MemBuddy | t.CPtr,
                     name: str, names_ptr: t.CSizeT | t.CPtr,
                     count: int) -> int:
    """设置结构体的父类名数组（永久池深拷贝，委托到 gen.set_parent_names）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.set_parent_names(pool, name, names_ptr, count)
    return 0


def get_parent_count(name: str) -> int:
    """获取父类数量（0=无父类，1=单继承，>1=多继承，委托到 gen.get_parent_count）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.get_parent_count(name)
    return 0


def get_parent_name_at(name: str, idx: int) -> str:
    """获取第 idx 个父类名，越界返回 None（委托到 gen.get_parent_name_at）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.get_parent_name_at(name, idx)
    return None


def get_mro_chain(pool: memhub.MemBuddy | t.CPtr,
                  name: str) -> t.CSizeT | t.CPtr:
    """MRO 线性化类名数组（深度优先 + 声明顺序 + 去重，含自身，委托到 gen.get_mro_chain）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.get_mro_chain(pool, name)
    return None


def get_parent_name(name: str) -> str:
    """获取结构体的父类名，返回 None=无父类（委托到 gen.get_parent_name）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.get_parent_name(name)
    return None


def set_vtable_methods(name: str, methods: str, count: int) -> int:
    """设置虚表方法名数组，返回 1=成功 / 0=失败（委托到 gen.set_vtable_methods）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.set_vtable_methods(name, methods, count)
    return 0


def get_vtable_method_index(name: str, method_name: str) -> int:
    """获取方法在虚表中的索引，返回 -1=未找到（委托到 gen.get_vtable_method_index）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.get_vtable_method_index(name, method_name)
    return 0


def get_vtable_method_count(name: str) -> int:
    """获取虚表方法数量（委托到 gen.get_vtable_method_count）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.get_vtable_method_count(name)
    return 0


def get_vtable_method_name(name: str, idx: int) -> str:
    """获取虚表中第 idx 个方法名，返回 None=越界（委托到 gen.get_vtable_method_name）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.get_vtable_method_name(name, idx)
    return None


def get_field_count(name: str) -> int:
    """获取结构体字段数量，返回 -1=未找到（委托到 gen.get_field_count）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.get_field_count(name)
    return 0


def ensure_struct_def_in_module(pool: memhub.MemBuddy | t.CPtr,
                                mod: llvmlite.LLVMModule | t.CPtr,
                                ty: llvmlite.LLVMType | t.CPtr):
    """确保跨模块结构体的完整定义在当前模块中可用（委托到 gen.ensure_struct_def_in_module）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        g.ensure_struct_def_in_module(pool, mod, ty)


def _ensure_field_types_in_module(pool: memhub.MemBuddy | t.CPtr,
                                  mod: llvmlite.LLVMModule | t.CPtr,
                                  ty: llvmlite.LLVMType | t.CPtr):
    """递归扫描类型树，确保值类型子结构体有完整定义（委托到 gen._ensure_field_types_in_module）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        g._ensure_field_types_in_module(pool, mod, ty)


def get_field_name_ptr(fe: FieldEntry | t.CPtr) -> str:
    """获取 FieldEntry 的字段名，返回 None=未设置（委托到 gen.get_field_name_ptr）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.get_field_name_ptr(fe)
    return None


def get_field_type_ptr(fe: FieldEntry | t.CPtr) -> llvmlite.LLVMType | t.CPtr:
    """获取 FieldEntry 的字段类型，返回 None=未设置（委托到 gen.get_field_type_ptr）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.get_field_type_ptr(fe)
    return None


def get_field_default_ptr(fe: FieldEntry | t.CPtr) -> ast.AST | t.CPtr:
    """获取 FieldEntry 的默认值 AST 节点，返回 None=无默认值（委托到 gen.get_field_default_ptr）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.get_field_default_ptr(fe)
    return None


def get_field_annot_class_name(fe: FieldEntry | t.CPtr) -> str:
    """获取 FieldEntry 的原始类型注解类名，返回 None=未设置（委托到 gen.get_field_annot_class_name）"""
    import lib.core.Gen.Generator as Generator
    g: Generator.Generator | t.CPtr = (Generator.Generator | t.CPtr)(t.CVoid(_g_gen, t.CPtr))
    if g is not None:
        return g.get_field_annot_class_name(fe)
    return None