chore(gen): 全量备份——Handles 委托壳瘦身与单例注入统一

- 删除 Handles 各模块已迁移至 Gen 的旧函数体，保留一行委托壳（25 文件 -798 行） - main.vp / BuildPipeline.vp 全局单例注入改为 _g_gen 直接赋值 - 机械化迁移测试前的基线备份
2026-08-20 05:33:59 +08:00
1 parent a42923cf25
commit e07ea491a5
@@ -164,7 +164,7 @@ def TranslateFileGetTrans(mb: memhub.MemBuddy | t.CPtr, file_path: str,
    tr._declare_only = declare_only
    # P2: 复用全局 gen 单例（App/main.vp 创建；HandlesType 等旧模块函数经
    # 延迟 import 委托到 gen 方法）。单例未注册时兜底创建（防御直接调用路径）。
-    gen: GenGenerator.Generator | t.CPtr = GenGenerator.get_global_gen()
+    gen: GenGenerator.Generator | t.CPtr = GenGenerator._g_gen
    if gen is None:
        gen = mb.alloc(GenGenerator.Generator.__sizeof__())
        if gen is None:
@@ -172,31 +172,31 @@ def TranslateFileGetTrans(mb: memhub.MemBuddy | t.CPtr, file_path: str,
            return None
        gen.__before_init__()
        gen.__init__(mb)
-        GenGenerator.set_global_gen(gen)
+        GenGenerator._g_gen = gen
    # P2-P5: 注入各 Handles 模块级单例（委托函数经本地 _g_gen 访问，
    # 避免函数体 import 包模块与类/模块名歧义）
-    HandlesType.set_global_gen(gen)
-    HandlesStruct.set_global_gen(gen)
-    HandlesExpr.set_global_gen(gen)
-    HandlesExprOps.set_global_gen(gen)
-    HandlesExprCall.set_global_gen(gen)
-    HandlesFunctions.set_global_gen(gen)
-    HandlesClassDef.set_global_gen(gen)
+    HandlesType._g_gen = gen
+    HandlesStruct._g_gen = gen
+    HandlesExpr._g_gen = gen
+    HandlesExprOps._g_gen = gen
+    HandlesExprCall._g_gen = gen
+    HandlesFunctions._g_gen = gen
+    HandlesClassDef._g_gen = gen
    # P6: 注入语句/赋值/变量/导入/翻译驱动模块的单例
-    HandlesImports.set_global_gen(gen)
-    HandlesBody.set_global_gen(gen)
-    HandlesIf.set_global_gen(gen)
-    HandlesWhile.set_global_gen(gen)
-    HandlesFor.set_global_gen(gen)
-    HandlesReturn.set_global_gen(gen)
-    HandlesNonlocal.set_global_gen(gen)
-    HandlesMatch.set_global_gen(gen)
-    HandlesEnum.set_global_gen(gen)
-    HandlesAnnAssign.set_global_gen(gen)
-    HandlesAugAssign.set_global_gen(gen)
-    HandlesVar.set_global_gen(gen)
-    HandlesTranslator.set_global_gen(gen)
-    HandlesMain.set_global_gen(gen)
+    HandlesImports._g_gen = gen
+    HandlesBody._g_gen = gen
+    HandlesIf._g_gen = gen
+    HandlesWhile._g_gen = gen
+    HandlesFor._g_gen = gen
+    HandlesReturn._g_gen = gen
+    HandlesNonlocal._g_gen = gen
+    HandlesMatch._g_gen = gen
+    HandlesEnum._g_gen = gen
+    HandlesAnnAssign._g_gen = gen
+    HandlesAugAssign._g_gen = gen
+    HandlesVar._g_gen = gen
+    HandlesTranslator._g_gen = gen
+    HandlesMain._g_gen = gen
    # 设置当前文件名（供报错使用）
    HandlesType.set_current_file(file_path)
    # 同步到 HandlesImports（import 时 SHA1 检查报错需要当前文件名，循环依赖无法直接读 HandlesType）
@@ -227,21 +227,5 @@ class Generator(BaseGenMixin.BaseGenMixin, TypeGenMixin.TypeGenMixin,

 # ============================================================
 # 全局生成器单例（对象化 P2 兼容层）
-#
-# 从 Gen/__init__.vp（包）迁入本模块（普通模块）：TPC 的模块名注册
-# 只注册"普通模块短名"（如 Generator）与"完整包名"（如 lib.core.Gen），
-# 不注册包短名（如 Gen）。HandlesType 等旧模块的函数体 import 若引
-# 用包短名会报 Unknown module，故单例存取放在非包模块，别名用短名。
 # ============================================================
 _g_gen: Generator | t.CPtr = None
-
-
-def set_global_gen(gen: Generator | t.CPtr) -> None:
-    """注册全局生成器单例（App/main.vp 创建 gen 后调用）"""
-    global _g_gen
-    _g_gen = gen
-
-
-def get_global_gen() -> Generator | t.CPtr:
-    """获取全局生成器单例（未注册返回 None）"""
-    return _g_gen
@@ -15,7 +15,7 @@ import lib.core.Handles.HandlesType as HandlesType
 import lib.core.Handles.HandlesExprCall as HandlesExprCall
 import lib.core.Handles.HandlesStruct as HandlesStruct
 import lib.core.Handles.ExprCallBase as ExprCallBase
-
+from lib.core.Handles.HandlesFor import SEQ_KIND_RANGE, SEQ_KIND_STR, SEQ_KIND_LIST

 # ============================================================
 # ForHandleBase - HandlesFor 拆分（阶段 E）：ForHandleBase
@@ -19,25 +19,13 @@ import lib.core.Handles.HandlesStruct as HandlesStruct
 import lib.core.VLogger as VLogger
 import lib.core.Handles.ExprCallCall as ExprCallCall
 import lib.core.Handles.ExprCallCtor as ExprCallCtor
+import lib.core.Gen.Generator as Generator


 # ============================================================
 # 全局 gen 单例（模块级镜像，同 HandlesType/HandlesStruct 模式）
-#
-# 由 BuildPipeline/main 在 gen 创建后调用 set_global_gen 注入。
-# P6 对象化重构：模块级无状态函数已迁移为 lib.core.Gen.AssignGenMixin
-# 的方法（_g_recover_found 全局迁入 gen 字段 RecoverFound），本模块保留
-# 同名模块级函数作为"一行委托"：延迟 import Gen 取全局单例
-# （BuildPipeline/main 创建后 set_global_gen 注册），再调用 gen 的
-# 对应方法。签名与旧函数完全一致，调用方零改动。
 # ============================================================
-_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
+_g_gen: Generator.Generator | t.CPtr = None


 # ============================================================
@@ -54,7 +42,6 @@ def set_global_gen(gen: t.CVoid | t.CPtr) -> None:
 # ============================================================
 def is_cdefine_annotation(annot: ast.AST | t.CPtr) -> int:
    """检测注解是否为 t.CDefine，返回 1 表示是，0 表示否（委托到 gen.is_cdefine_annotation）"""
-    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_cdefine_annotation(annot)
@@ -63,7 +50,6 @@ def is_cdefine_annotation(annot: ast.AST | t.CPtr) -> int:

 def is_ctypedef_annotation(annot: ast.AST | t.CPtr) -> int:
    """检测注解是否为 t.CTypedef，返回 1 表示是，0 表示否（委托到 gen._is_ctypedef_annotation）"""
-    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_ctypedef_annotation(annot)
@@ -82,7 +68,6 @@ def is_ctypedef_annotation(annot: ast.AST | t.CPtr) -> int:
 # ============================================================
 def extract_cdefine_int_value(val_node: ast.AST | t.CPtr) -> t.CInt64T:
    """从值节点提取整数常量（支持 Constant/BinOp/Name/Call/UnaryOp，委托到 gen.extract_cdefine_int_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.extract_cdefine_int_value(val_node)
@@ -99,7 +84,6 @@ def extract_cdefine_int_value(val_node: ast.AST | t.CPtr) -> t.CInt64T:
 def _register_cdefine_from_value(pool: memhub.MemBuddy | t.CPtr,
                                 name: str, val_node: ast.AST | t.CPtr) -> None:
    """注册 CDefine 常量（浮点字面量 → register_cdefine_double，否则整数，委托到 gen._register_cdefine_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:
        g._register_cdefine_from_value(pool, name, val_node)
@@ -118,7 +102,6 @@ def _register_cdefine_from_value(pool: memhub.MemBuddy | t.CPtr,

 def _recover_found() -> int:
    """检查最近一次 _recover_cdefine_float 是否成功（委托到 gen._recover_found）"""
-    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._recover_found()
@@ -131,7 +114,6 @@ def _recover_cdefine_float(name: str, out: t.CDouble | t.CPtr) -> int:
    用输出参数传递 double，避免 TPV 跨模块 double 返回值传递 bug。
    （委托到 gen._recover_cdefine_float）
    """
-    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._recover_cdefine_float(name, out)
@@ -145,7 +127,6 @@ def _recover_cdefine_float(name: str, out: t.CDouble | t.CPtr) -> int:
 # ============================================================
 def _annotation_contains_name(annot: ast.AST | t.CPtr, name: str) -> int:
    """递归检查注解中是否包含指定名称，返回 1=包含 / 0=不包含（委托到 gen._annotation_contains_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._annotation_contains_name(annot, name)
@@ -166,7 +147,6 @@ def _annotation_contains_name(annot: ast.AST | t.CPtr, name: str) -> int:
 # ============================================================
 def _is_ptr_element_annotation(annot: ast.AST | t.CPtr) -> int:
    """检查注解是否为 bytes|t.CPtr 或 str|t.CPtr 形式（委托到 gen._is_ptr_element_annotation）"""
-    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_ptr_element_annotation(annot)
@@ -275,7 +255,6 @@ def _init_global_array_from_list(builder: llvmlite.IRBuilder | t.CPtr,
                                 list_node: ast.AST | t.CPtr,
                                 trans: HT.Translator | t.CPtr) -> int:
    """从列表字面量初始化全局数组，为每个元素生成 GEP + store（委托到 gen._init_global_array_from_list）"""
-    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_global_array_from_list(builder, pool, mod, array_alloca, list_node, trans)
@@ -13,24 +13,13 @@ import lib.core.Handles.HandlesVar as HandlesVar
 import lib.core.Handles.HandlesExpr as HandlesExpr
 import lib.core.Handles.HandlesNonlocal as HandlesNonlocal
 import lib.core.Handles.HandlesType as HandlesType
+import lib.core.Gen.Generator as Generator


 # ============================================================
 # 全局 gen 单例（模块级镜像，同 HandlesType/HandlesStruct 模式）
-#
-# 由 BuildPipeline/main 在 gen 创建后调用 set_global_gen 注入。
-# P6 对象化重构：模块级无状态函数已迁移为 lib.core.Gen.AssignGenMixin
-# 的方法，本模块保留同名模块级函数作为"一行委托"：延迟 import Gen
-# 取全局单例（BuildPipeline/main 创建后 set_global_gen 注册），再调用
-# gen 的对应方法。签名与旧函数完全一致，调用方零改动。
 # ============================================================
-_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
+_g_gen: Generator.Generator | t.CPtr = None


 # ============================================================
@@ -280,7 +269,6 @@ def _apply_aug_op(pool: memhub.MemBuddy | t.CPtr,
                  trans: HT.Translator | t.CPtr = None,
                  lhs_node: ast.AST | t.CPtr = None) -> llvmlite.Value | t.CPtr:
    """应用增强赋值的二元运算（浮点 + 指针算术 + 整数运算，委托到 gen._apply_aug_op）"""
-    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._apply_aug_op(pool, builder, op, lhs, rhs, node, trans, lhs_node)
@@ -12,6 +12,7 @@ import lib.core.Handles.HandlesExprCall as HandlesExprCall
 import lib.core.Handles.HandlesFunctions as HandlesFunctions
 import lib.core.Handles.HandlesClassDef as HandlesClassDef
 import lib.core.Handles.HandlesVar as HandlesVar
+import lib.core.Gen.Generator as Generator


 # ============================================================
@@ -29,18 +30,8 @@ import lib.core.Handles.HandlesVar as HandlesVar

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


 # ============================================================
@@ -49,7 +40,6 @@ def set_global_gen(gen: t.CVoid | t.CPtr) -> None:
 def translate_stmt(trans: HT.Translator | t.CPtr,
                   node: ast.AST | t.CPtr) -> int:
    """翻译单条语句，返回新增的变量数（委托到 gen.translate_stmt）"""
-    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.translate_stmt(trans, node)
@@ -65,7 +55,6 @@ def translate_stmt(trans: HT.Translator | t.CPtr,
 def translate_delete(trans: HT.Translator | t.CPtr,
                     node: ast.AST | t.CPtr) -> int:
    """翻译 del 语句，返回 0（委托到 gen.translate_delete）"""
-    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.translate_delete(trans, node)
@@ -80,7 +69,6 @@ def translate_delete(trans: HT.Translator | t.CPtr,
 def translate_global(trans: HT.Translator | t.CPtr,
                     node: ast.AST | t.CPtr) -> int:
    """翻译 global 语句：记录 global 变量名（委托到 gen.translate_global）"""
-    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.translate_global(trans, node)
@@ -98,7 +86,6 @@ def translate_nonlocal(trans: HT.Translator | t.CPtr,

    类型信息通过查找父作用域的 alloca 获取（用于 env 指针数组方案的类型恢复）。
    """
-    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.translate_nonlocal(trans, node)
@@ -111,7 +98,6 @@ def translate_nonlocal(trans: HT.Translator | t.CPtr,
 def translate_expr_stmt(trans: HT.Translator | t.CPtr,
                        node: ast.AST | t.CPtr) -> int:
    """翻译表达式语句（printf 调用等）（委托到 gen.translate_expr_stmt）"""
-    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.translate_expr_stmt(trans, node)
@@ -127,7 +113,6 @@ def pre_scan_allocas(trans: HT.Translator | t.CPtr,

    返回新增的变量数
    """
-    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.pre_scan_allocas(trans, node)
@@ -144,7 +129,6 @@ def pre_scan_allocas(trans: HT.Translator | t.CPtr,
 def pre_scan_scope_decls(trans: HT.Translator | t.CPtr,
                         node: ast.AST | t.CPtr) -> int:
    """预扫描 Global/Nonlocal 声明，提前注册作用域名称（委托到 gen.pre_scan_scope_decls）"""
-    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.pre_scan_scope_decls(trans, node)
@@ -156,7 +140,6 @@ def pre_scan_scope_decls(trans: HT.Translator | t.CPtr,
 # ============================================================
 def translate_break(trans: HT.Translator | t.CPtr) -> int:
    """翻译 break 语句：跳转到循环 end 块（委托到 gen.translate_break）"""
-    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.translate_break(trans)
@@ -168,7 +151,6 @@ def translate_break(trans: HT.Translator | t.CPtr) -> int:
 # ============================================================
 def translate_continue(trans: HT.Translator | t.CPtr) -> int:
    """翻译 continue 语句：跳转到循环 cond/incr 块（委托到 gen.translate_continue）"""
-    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.translate_continue(trans)
@@ -180,7 +162,6 @@ def translate_continue(trans: HT.Translator | t.CPtr) -> int:
 # ============================================================
 def get_stmt_kind_name(node: ast.AST | t.CPtr) -> str:
    """获取语句类型名（委托到 gen.get_stmt_kind_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_stmt_kind_name(node)
@@ -14,22 +14,13 @@ import lib.core.Handles.HandlesStruct as HandlesStruct
 import lib.core.Handles.HandlesVar as HandlesVar
 import lib.core.Handles.HandlesEnum as HandlesEnum
 import lib.core.StubMerger as StubMerger
+import lib.core.Gen.Generator as Generator


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


 # 枚举成员临时数组最大数量（本地常量）
@@ -67,7 +58,6 @@ RENUM_FIELD_PER_VARIANT: t.CDefine = 16
 def _is_cenum_base(base_node: ast.AST | t.CPtr,
                   trans: HT.Translator | t.CPtr = None) -> int:
    """检查 base 节点是否为 t.CEnum，返回 1=是 / 0=否（委托到 gen._is_cenum_base）"""
-    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_cenum_base(base_node, trans)
@@ -80,7 +70,6 @@ def _is_cenum_base(base_node: ast.AST | t.CPtr,
 def _is_enum_class(cd: ast.ClassDef | t.CPtr,
                   trans: HT.Translator | t.CPtr = None) -> int:
    """检查 ClassDef 是否继承自 t.CEnum，返回 1=是 / 0=否（委托到 gen._is_enum_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._is_enum_class(cd, trans)
@@ -95,7 +84,6 @@ def _is_enum_class(cd: ast.ClassDef | t.CPtr,
 def _is_cunion_base(base_node: ast.AST | t.CPtr,
                    trans: HT.Translator | t.CPtr = None) -> int:
    """检查 base 节点是否为 t.CUnion，返回 1=是 / 0=否（委托到 gen._is_cunion_base）"""
-    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_cunion_base(base_node, trans)
@@ -108,7 +96,6 @@ def _is_cunion_base(base_node: ast.AST | t.CPtr,
 def _is_union_class(cd: ast.ClassDef | t.CPtr,
                    trans: HT.Translator | t.CPtr = None) -> int:
    """检查 ClassDef 是否继承自 t.CUnion，返回 1=是 / 0=否（委托到 gen._is_union_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._is_union_class(cd, trans)
@@ -123,7 +110,6 @@ def _is_union_class(cd: ast.ClassDef | t.CPtr,
 def _is_crenum_base(base_node: ast.AST | t.CPtr,
                    trans: HT.Translator | t.CPtr = None) -> int:
    """检查 base 节点是否为 t.REnum，返回 1=是 / 0=否（委托到 gen._is_crenum_base）"""
-    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_crenum_base(base_node, trans)
@@ -136,7 +122,6 @@ def _is_crenum_base(base_node: ast.AST | t.CPtr,
 def _is_renum_class(cd: ast.ClassDef | t.CPtr,
                    trans: HT.Translator | t.CPtr = None) -> int:
    """检查 ClassDef 是否继承自 t.REnum，返回 1=是 / 0=否（委托到 gen._is_renum_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._is_renum_class(cd, trans)
@@ -162,7 +147,6 @@ _MARKER_BASES: t.CDefine = 9
 def _has_decorator(decorator_list: list[ast.AST | t.CPtr] | t.CPtr,
                   deco_name: str) -> int:
    """检查 decorator_list 中是否有指定装饰器名（委托到 gen._has_decorator）"""
-    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_decorator(decorator_list, deco_name)
@@ -173,7 +157,6 @@ def register_decorator(pool: memhub.MemBuddy | t.CPtr,
                       func_name: str, wrapper_name: str,
                       arg0: t.CInt64T) -> int:
    """注册自定义装饰器函数（@log/@skip/@repeat(3) → __decor_wrap_{name}，委托到 gen）"""
-    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_decorator(pool, func_name, wrapper_name, arg0)
@@ -182,7 +165,6 @@ def register_decorator(pool: memhub.MemBuddy | t.CPtr,

 def lookup_decor_wrapper(func_name: str) -> str:
    """按原函数名查装饰器 wrapper 名，未注册返回 None（委托到 gen）"""
-    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_decor_wrapper(func_name)
@@ -191,7 +173,6 @@ def lookup_decor_wrapper(func_name: str) -> str:

 def lookup_decor_arg0(func_name: str) -> t.CInt64T:
    """按原函数名查装饰器首个常量参数（无参数为 0，委托到 gen）"""
-    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_decor_arg0(func_name)
@@ -203,7 +184,6 @@ def lookup_decor_arg0(func_name: str) -> t.CInt64T:
 # ============================================================
 def register_exception(class_name: str, parent_name: str) -> int:
    """注册用户异常类并分配编码（幂等，委托到 gen）。返回编码或 -1"""
-    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_exception(class_name, parent_name)
@@ -212,7 +192,6 @@ def register_exception(class_name: str, parent_name: str) -> int:

 def lookup_exception_code(name: str) -> int:
    """查异常编码：内置表优先，其次用户异常表（委托到 gen）"""
-    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_exception_code(name)
@@ -221,7 +200,6 @@ def lookup_exception_code(name: str) -> int:

 def is_exception_name(name: str) -> int:
    """name 是否是内置或用户异常类名（委托到 gen）"""
-    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_exception_name(name)
@@ -231,7 +209,6 @@ def is_exception_name(name: str) -> int:
 def collect_descendant_codes(name: str, out_codes: t.CInt | t.CPtr,
                             max_codes: int) -> int:
    """收集 name 及全部子孙异常编码（委托到 gen）"""
-    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.collect_descendant_codes(name, out_codes, max_codes)
@@ -241,7 +218,6 @@ def collect_descendant_codes(name: str, out_codes: t.CInt | t.CPtr,
 def register_exception_class_def(trans: HT.Translator | t.CPtr,
                                 cd: ast.ClassDef | t.CPtr) -> int:
    """注册异常类定义（分配编码 + 记录父类，不生成 struct，委托到 gen）"""
-    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_exception_class_def(trans, cd)
@@ -282,7 +258,6 @@ META_KEY_LEN: t.CDefine = 128
 # ============================================================
 def _extract_func_meta(decorator_list: list[ast.AST | t.CPtr] | t.CPtr) -> int:
    """从装饰器列表提取元数据位掩码，返回 0=无装饰器元数据（委托到 gen._extract_func_meta）"""
-    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_func_meta(decorator_list)
@@ -297,7 +272,6 @@ def _extract_func_meta(decorator_list: list[ast.AST | t.CPtr] | t.CPtr) -> int:
 def register_method_meta(class_name: str, method_name: str,
                         meta: int) -> None:
    """注册方法元数据（幂等，委托到 gen.register_method_meta）"""
-    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.register_method_meta(class_name, method_name, meta)
@@ -310,7 +284,6 @@ def register_method_meta(class_name: str, method_name: str,
 # ============================================================
 def lookup_method_meta(class_name: str, method_name: str) -> int:
    """查找方法元数据位掩码，返回 0=未注册或非装饰器方法（委托到 gen.lookup_method_meta）"""
-    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_method_meta(class_name, method_name)
@@ -335,7 +308,6 @@ def _is_marker_base(base_name: str) -> int:
    与 TPC（_resolve_base_kind 对 t.Struct 返回 None → 无父类）保持一致。
    （委托到 gen._is_marker_base）
    """
-    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_marker_base(base_name)
@@ -356,7 +328,6 @@ def _get_base_name(base_node: ast.AST | t.CPtr,
    pool=None 时降级返回基类名（不含类型实参）
    （委托到 gen._get_base_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_base_name(base_node, pool)
@@ -373,7 +344,6 @@ def _get_base_name(base_node: ast.AST | t.CPtr,
 def _get_parent_class(cd: ast.ClassDef | t.CPtr,
                      trans: HT.Translator | t.CPtr = None) -> str:
    """获取 ClassDef 的真实父类名，返回 None=无真实父类（委托到 gen._get_parent_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._get_parent_class(cd, trans)
@@ -393,7 +363,6 @@ def _collect_parents(pool: memhub.MemBuddy | t.CPtr,
                     max_parents: int,
                     trans: HT.Translator | t.CPtr = None) -> int:
    """收集所有非 marker 父类名到 parents_buf，返回数量（委托到 gen._collect_parents）"""
-    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._collect_parents(pool, cd, parents_buf, max_parents, trans)
@@ -406,7 +375,6 @@ def _collect_parents(pool: memhub.MemBuddy | t.CPtr,
 def _field_name_exists(names_buf: t.CSizeT | t.CPtr,
                       count: int, name: str) -> int:
    """检查字段名是否已在 names_buf 中（先声明父类优先，重复跳过）（委托到 gen._field_name_exists）"""
-    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._field_name_exists(names_buf, count, name)
@@ -421,7 +389,6 @@ def _field_name_exists(names_buf: t.CSizeT | t.CPtr,
 # ============================================================
 def _class_body_has_field(cd: ast.ClassDef | t.CPtr) -> int:
    """检查类体是否声明了字段（AnnAssign），0=纯方法/无字段类（委托到 gen._class_body_has_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._class_body_has_field(cd)
@@ -441,7 +408,6 @@ def _class_body_has_field(cd: ast.ClassDef | t.CPtr) -> int:
 def _trigger_base_specialization(trans: HT.Translator | t.CPtr,
                                  cd: ast.ClassDef | t.CPtr):
    """触发 base 中 Subscript 的泛型特化（如 GSListNode[Value]）（委托到 gen._trigger_base_specialization）"""
-    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._trigger_base_specialization(trans, cd)
@@ -455,7 +421,6 @@ def _trigger_base_specialization(trans: HT.Translator | t.CPtr,
 # ============================================================
 def _has_any_func_cvtable(cd: ast.ClassDef | t.CPtr) -> int:
    """检查类中是否有任何函数标记了 @t.CVTable，返回 1=有 / 0=无（委托到 gen._has_any_func_cvtable）"""
-    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_any_func_cvtable(cd)
@@ -476,7 +441,6 @@ def _should_method_be_virtual(cd: ast.ClassDef | t.CPtr,
                               fd: ast.FunctionDef | t.CPtr,
                               trans: HT.Translator | t.CPtr = None) -> int:
    """判断方法是否应该进入虚表，返回 1=包含 / 0=排除（委托到 gen._should_method_be_virtual）"""
-    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._should_method_be_virtual(cd, fd, trans)
@@ -497,7 +461,6 @@ def _should_method_be_virtual(cd: ast.ClassDef | t.CPtr,
 def _detect_vtable_status(cd: ast.ClassDef | t.CPtr,
                          trans: HT.Translator | t.CPtr = None) -> int:
    """检测类是否应该启用虚表（委托到 gen._detect_vtable_status）"""
-    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._detect_vtable_status(cd, trans)
@@ -516,7 +479,6 @@ def _resolve_enum_member_type(pool: memhub.MemBuddy | t.CPtr,
                              imported_modules: str,
                              from_imports: str) -> llvmlite.LLVMType | t.CPtr:
    """解析枚举成员的类型注解为 LLVM 整数类型（委托到 gen._resolve_enum_member_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._resolve_enum_member_type(pool, ann_node, imported_modules, from_imports)
@@ -528,7 +490,6 @@ def _resolve_enum_member_type(pool: memhub.MemBuddy | t.CPtr,
 # ============================================================
 def _is_state_annotation(node: ast.AST | t.CPtr) -> int:
    """检查注解节点是否为 t.State，返回 1=是 / 0=否（委托到 gen._is_state_annotation）"""
-    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_state_annotation(node)
@@ -542,7 +503,6 @@ def _is_state_annotation(node: ast.AST | t.CPtr) -> int:
 # ============================================================
 def _extract_int_value(node: ast.AST | t.CPtr) -> t.CInt64T:
    """从 AST 节点提取整数值，失败返回 0（委托到 gen._extract_int_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._extract_int_value(node)
@@ -559,7 +519,6 @@ def _extract_int_value(node: ast.AST | t.CPtr) -> t.CInt64T:
 def _translate_enum_def(trans: HT.Translator | t.CPtr,
                        cd: ast.ClassDef | t.CPtr) -> int:
    """翻译枚举类定义，返回 0（委托到 gen._translate_enum_def）"""
-    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._translate_enum_def(trans, cd)
@@ -573,7 +532,6 @@ def _translate_enum_def(trans: HT.Translator | t.CPtr,
 # ============================================================
 def _get_type_size(ty: llvmlite.LLVMType | t.CPtr) -> int:
    """计算 LLVM 类型的字节大小（含对齐 padding）（委托到 gen._get_type_size）"""
-    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_type_size(ty)
@@ -582,7 +540,6 @@ def _get_type_size(ty: llvmlite.LLVMType | t.CPtr) -> int:

 def _get_type_align(ty: llvmlite.LLVMType | t.CPtr) -> int:
    """返回类型的自然对齐（字节）（委托到 gen._get_type_align）"""
-    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_type_align(ty)
@@ -608,7 +565,6 @@ def _get_type_align(ty: llvmlite.LLVMType | t.CPtr) -> int:
 def _translate_union_def(trans: HT.Translator | t.CPtr,
                         cd: ast.ClassDef | t.CPtr) -> int:
    """翻译联合体定义，返回 0（委托到 gen._translate_union_def）"""
-    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._translate_union_def(trans, cd)
@@ -624,7 +580,6 @@ def _translate_union_def(trans: HT.Translator | t.CPtr,
 # ============================================================
 def _get_annotation_field_size(annotation: ast.AST | t.CPtr) -> int:
    """计算注解类型的字节大小，用于 REnum 布局计算（委托到 gen._get_annotation_field_size）"""
-    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_annotation_field_size(annotation)
@@ -653,7 +608,6 @@ def _get_annotation_field_size(annotation: ast.AST | t.CPtr) -> int:
 def _translate_renum_def(trans: HT.Translator | t.CPtr,
                          cd: ast.ClassDef | t.CPtr) -> int:
    """翻译 REnum 类定义，返回 0（委托到 gen._translate_renum_def）"""
-    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._translate_renum_def(trans, cd)
@@ -706,7 +660,6 @@ def _register_renum_variants(pool: memhub.MemBuddy | t.CPtr,
                             cd: ast.ClassDef | t.CPtr,
                             variant_count: int):
    """注册 REnum 类的变体名和 tag 值到全局变体表（委托到 gen._register_renum_variants）"""
-    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._register_renum_variants(pool, class_name, cd, variant_count)
@@ -728,7 +681,6 @@ def _lookup_renum_variant(variant_name: str) -> str:

    返回: class_name (str)，或 None（委托到 gen._lookup_renum_variant）
    """
-    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_renum_variant(variant_name)
@@ -743,7 +695,6 @@ def _lookup_renum_variant(variant_name: str) -> str:
 # ============================================================
 def _is_renum_class_name(class_name: str) -> int:
    """检查名称是否是已注册的 REnum 类名，返回 1=是 / 0=否（委托到 gen._is_renum_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._is_renum_class_name(class_name)
@@ -763,7 +714,6 @@ def _is_renum_class_name(class_name: str) -> int:
 # ============================================================
 def _lookup_renum_variant_in_class(class_name: str, variant_name: str) -> int:
    """在指定 REnum 类中查找变体，返回 tag 值或 -1（委托到 gen._lookup_renum_variant_in_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_renum_variant_in_class(class_name, variant_name)
@@ -793,7 +743,6 @@ def _register_renum_field_alias(pool: memhub.MemBuddy | t.CPtr,
    field_ty: 变体成员实际 LLVM 类型（可选，供 match 绑定 bitcast）
    variant_name: 所属变体名（可选，match 绑定按 (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:
        g._register_renum_field_alias(pool, class_name, field_name, payload_idx,
@@ -814,7 +763,6 @@ def _register_renum_field_alias(pool: memhub.MemBuddy | t.CPtr,
 # ============================================================
 def _update_renum_alias_class_ptr(old_ptr: t.CSizeT, new_ptr: t.CSizeT):
    """更新别名表中的 class_name 指针，从 old_ptr 更新为 new_ptr（委托到 gen._update_renum_alias_class_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:
        g._update_renum_alias_class_ptr(old_ptr, new_ptr)
@@ -838,7 +786,6 @@ def _lookup_renum_field_alias(class_name: str, field_name: str) -> int:
    field_name: 用 strcmp 内容比较（注册时 vnm.id 与查找时 at.attr 是不同指针）
    （委托到 gen._lookup_renum_field_alias）
    """
-    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_renum_field_alias(class_name, field_name)
@@ -858,7 +805,6 @@ def _lookup_renum_field_alias(class_name: str, field_name: str) -> int:
 def _lookup_renum_field_alias_ty(class_name: str,
                                 field_name: str) -> llvmlite.LLVMType | t.CPtr:
    """查找 REnum 变体成员的实际 LLVM 类型，返回类型或 None（委托到 gen._lookup_renum_field_alias_ty）"""
-    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_renum_field_alias_ty(class_name, field_name)
@@ -878,7 +824,6 @@ def _lookup_renum_member_ty(class_name: str,
                            variant_name: str,
                            payload_idx: int) -> llvmlite.LLVMType | t.CPtr:
    """按 (class, 变体名, payload 位置) 查找变体成员实际类型，返回类型或 None（委托到 gen._lookup_renum_member_ty）"""
-    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_renum_member_ty(class_name, variant_name, payload_idx)
@@ -904,7 +849,6 @@ def _lookup_renum_member_ty(class_name: str,

 def _is_generic_class(tp: list[str] | t.CPtr) -> int:
    """检查 ClassDef 是否有类型参数（泛型类），返回 1=是 / 0=否（委托到 gen._is_generic_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._is_generic_class(tp)
@@ -915,7 +859,6 @@ def _register_generic_template(pool: memhub.MemBuddy | t.CPtr,
                               cd: ast.ClassDef | t.CPtr,
                               module_sha1: str):
    """注册泛型类模板（类名 + ClassDef 节点 + 来源模块 SHA1）（委托到 gen._register_generic_template）"""
-    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._register_generic_template(pool, cd, module_sha1)
@@ -923,7 +866,6 @@ def _register_generic_template(pool: memhub.MemBuddy | t.CPtr,

 def _find_generic_template(class_name: str) -> ast.ClassDef | t.CPtr:
    """查找泛型类模板，返回 ClassDef 节点或 None（委托到 gen._find_generic_template）"""
-    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_generic_template(class_name)
@@ -932,7 +874,6 @@ def _find_generic_template(class_name: str) -> ast.ClassDef | t.CPtr:

 def _find_generic_template_sha1(class_name: str) -> str:
    """查找泛型类模板的来源模块 SHA1，未找到返回 None（委托到 gen._find_generic_template_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._find_generic_template_sha1(class_name)
@@ -943,7 +884,6 @@ def _mangle_generic_class_name(pool: memhub.MemBuddy | t.CPtr,
                               class_name: str,
                               type_args: list[str] | t.CPtr) -> str:
    """生成特化类名: list + [int] -> list[int]（委托到 gen._mangle_generic_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._mangle_generic_class_name(pool, class_name, type_args)
@@ -963,7 +903,6 @@ def _clone_annotation(pool: memhub.MemBuddy | t.CPtr,
                      tp_names: list[str] | t.CPtr,
                      type_args: list[str] | t.CPtr) -> ast.AST | t.CPtr:
    """拷贝类型注解表达式，替换类型参数 T 为具体类型名（委托到 gen._clone_annotation）"""
-    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._clone_annotation(pool, node, tp_names, type_args)
@@ -975,7 +914,6 @@ def _clone_arguments(pool: memhub.MemBuddy | t.CPtr,
                     tp_names: list[str] | t.CPtr,
                     type_args: list[str] | t.CPtr) -> ast.AST | t.CPtr:
    """拷贝 Arguments 节点，替换 arg annotation 中的 T（委托到 gen._clone_arguments）"""
-    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._clone_arguments(pool, args, tp_names, type_args)
@@ -988,7 +926,6 @@ def _clone_classdef_for_spec(pool: memhub.MemBuddy | t.CPtr,
                             tp_names: list[str] | t.CPtr,
                             type_args: list[str] | t.CPtr) -> ast.ClassDef | t.CPtr:
    """拷贝 ClassDef 节点用于泛型特化（委托到 gen._clone_classdef_for_spec）"""
-    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._clone_classdef_for_spec(pool, cd, spec_name, tp_names, type_args)
@@ -1009,7 +946,6 @@ SPEC_CACHE_MAX: t.CDefine = 512

 def _find_cached_spec(spec_key: str) -> str:
    """查找已缓存的特化名，未找到返回 None（委托到 gen._find_cached_spec）"""
-    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_cached_spec(spec_key)
@@ -1018,7 +954,6 @@ def _find_cached_spec(spec_key: str) -> str:

 def _cache_spec(pool: memhub.MemBuddy | t.CPtr, spec_key: str, spec_name: str):
    """缓存特化结果（stdlib 深拷贝存储，跨文件安全）（委托到 gen._cache_spec）"""
-    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._cache_spec(pool, spec_key, spec_name)
@@ -1036,7 +971,6 @@ def _cache_spec(pool: memhub.MemBuddy | t.CPtr, spec_key: str, spec_name: str):
 def _merge_template_imports(trans: HT.Translator | t.CPtr,
                            template_sha1: str) -> None:
    """将模板模块的 imports 并入 trans._imported_modules（空格分隔）（委托到 gen._merge_template_imports）"""
-    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._merge_template_imports(trans, template_sha1)
@@ -1046,7 +980,6 @@ def _specialize_generic_class(trans: HT.Translator | t.CPtr,
                              class_name: str,
                              type_args: list[str] | t.CPtr) -> str:
    """特化泛型类，返回特化类名（委托到 gen._specialize_generic_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._specialize_generic_class(trans, class_name, type_args)
@@ -1056,7 +989,6 @@ def _specialize_generic_class(trans: HT.Translator | t.CPtr,
 def translate_class_def(trans: HT.Translator | t.CPtr,
                        node: ast.AST | t.CPtr) -> int:
    """翻译 class 定义，返回 0（委托到 gen.translate_class_def）"""
-    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.translate_class_def(trans, node)
@@ -1069,7 +1001,6 @@ def translate_class_def(trans: HT.Translator | t.CPtr,
 # ============================================================
 def _is_exception_class_def(cd: ast.ClassDef | t.CPtr) -> int:
    """类定义是否是异常类（委托到 gen._is_exception_class_def）"""
-    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_exception_class_def(cd)
@@ -1079,7 +1010,6 @@ def _is_exception_class_def(cd: ast.ClassDef | t.CPtr) -> int:
 def _register_exception_class_def(trans: HT.Translator | t.CPtr,
                                  cd: ast.ClassDef | t.CPtr) -> int:
    """注册异常类（分配编码 + 记录父类）（委托到 gen._register_exception_class_def）"""
-    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_exception_class_def(trans, cd)
@@ -1090,7 +1020,6 @@ def _register_class_meta_list(pool: memhub.MemBuddy | t.CPtr,
                              kind: int, cls: str,
                              value_node: ast.AST | t.CPtr) -> None:
    """解析类体 __provides__/__requires__ 的 list[str] 字面量并注册（委托到 gen._register_class_meta_list）"""
-    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._register_class_meta_list(pool, kind, cls, value_node)
@@ -1115,7 +1044,6 @@ VTBL_METHOD_MAX: t.CDefine = 32
 def _vtable_strcat(dst: str, dst_size: t.CSizeT,
                   src: str):
    """将 src 追加到 dst 末尾（委托到 gen._vtable_strcat）"""
-    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._vtable_strcat(dst, dst_size, src)
@@ -1124,7 +1052,6 @@ def _vtable_strcat(dst: str, dst_size: t.CSizeT,
 # _vtable_name_needs_quote — 检查 LLVM 标识符是否需要引号
 def _vtable_name_needs_quote(name: str) -> int:
    """检查 LLVM 标识符是否需要引号（以数字开头或含 '.'）（委托到 gen._vtable_name_needs_quote）"""
-    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._vtable_name_needs_quote(name)
@@ -1139,7 +1066,6 @@ def _format_func_type_str(pool: memhub.MemBuddy | t.CPtr,
                          buf: str, buf_size: t.CSizeT,
                          func: llvmlite.Function | t.CPtr) -> int:
    """从 Function 对象生成函数类型字符串（委托到 gen._format_func_type_str）"""
-    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._format_func_type_str(pool, buf, buf_size, func)
@@ -1175,7 +1101,6 @@ def _collect_vtable_methods(trans: HT.Translator | t.CPtr,
                            cd: ast.ClassDef | t.CPtr,
                            class_name: str) -> int:
    """收集虚方法信息，设置 entry.VTableMethods/VTableMethodCount（委托到 gen._collect_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._collect_vtable_methods(trans, cd, class_name)
@@ -1193,7 +1118,6 @@ def _generate_vtable(trans: HT.Translator | t.CPtr,
                     cd: ast.ClassDef | t.CPtr,
                     class_name: str) -> int:
    """生成 VTable 全局变量（委托到 gen._generate_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._generate_vtable(trans, cd, class_name)
@@ -1230,7 +1154,6 @@ def _translate_oop_methods(trans: HT.Translator | t.CPtr,
    reemit: 1=补译模式（泛型特化 Phase B 补译调用，强制发射方法体）
    （委托到 gen._translate_oop_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._translate_oop_methods(trans, cd, struct_ty, class_name, mark_only, reemit)
@@ -1251,7 +1174,6 @@ def _translate_method(trans: HT.Translator | t.CPtr,
                      struct_ty: llvmlite.LLVMType | t.CPtr,
                      class_name: str) -> int:
    """翻译单个方法，返回 0（委托到 gen._translate_method）"""
-    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._translate_method(trans, fd, struct_ty, class_name)
@@ -1272,7 +1194,6 @@ def _generate_before_init(trans: HT.Translator | t.CPtr,
                          struct_ty: llvmlite.LLVMType | t.CPtr,
                          class_name: str) -> int:
    """生成 __before_init__ 函数，返回 0（委托到 gen._generate_before_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._generate_before_init(trans, struct_ty, class_name)
@@ -6,6 +6,7 @@ import llvmlite
 import stdio
 import viperlib
 import lib.core.VLogger as VLogger
+import lib.core.Gen.Generator as Generator


 # ============================================================
@@ -53,18 +54,8 @@ class EnumEntry:

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


 # ============================================================
@@ -72,7 +63,6 @@ def set_global_gen(gen: t.CVoid | t.CPtr) -> None:
 # ============================================================
 def init_enum_table(pool: memhub.MemBuddy | t.CPtr) -> int:
    """初始化枚举注册表，返回 1 成功（委托到 gen.init_enum_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_enum_table(pool)
@@ -84,7 +74,6 @@ def init_enum_table(pool: memhub.MemBuddy | t.CPtr) -> int:
 # ============================================================
 def _get_enum_entry(i: int) -> EnumEntry | t.CPtr:
    """获取第 i 个枚举条目（委托到 gen._get_enum_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_enum_entry(i)
@@ -96,7 +85,6 @@ def _get_enum_entry(i: int) -> EnumEntry | t.CPtr:
 # ============================================================
 def _get_enum_member(enum_entry: EnumEntry | t.CPtr, i: int) -> EnumMember | t.CPtr:
    """获取枚举中第 i 个成员条目（委托到 gen._get_enum_member）"""
-    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_enum_member(enum_entry, i)
@@ -112,7 +100,6 @@ def register_enum(pool: memhub.MemBuddy | t.CPtr,
                  name: str,
                  base_ty: llvmlite.LLVMType | t.CPtr) -> EnumEntry | t.CPtr:
    """注册枚举类型，返回 EnumEntry 指针（委托到 gen.register_enum）"""
-    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_enum(pool, name, base_ty)
@@ -128,7 +115,6 @@ def add_enum_member(pool: memhub.MemBuddy | t.CPtr,
                    member_val: t.CInt64T,
                    member_ty: llvmlite.LLVMType | t.CPtr) -> int:
    """向枚举添加成员，返回成员索引（-1 失败，委托到 gen.add_enum_member）"""
-    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_enum_member(pool, enum_entry, member_name, member_val, member_ty)
@@ -140,7 +126,6 @@ def add_enum_member(pool: memhub.MemBuddy | t.CPtr,
 # ============================================================
 def find_enum(name: str) -> EnumEntry | t.CPtr:
    """按枚举类名查找，返回 EnumEntry 或 None（委托到 gen.find_enum）"""
-    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_enum(name)
@@ -153,7 +138,6 @@ def find_enum(name: str) -> EnumEntry | t.CPtr:
 def lookup_enum_member(enum_name: str,
                       member_name: str) -> EnumMember | t.CPtr:
    """按枚举类名和成员名查找，返回 EnumMember 或 None（委托到 gen.lookup_enum_member）"""
-    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_enum_member(enum_name, member_name)
@@ -165,7 +149,6 @@ def lookup_enum_member(enum_name: str,
 # ============================================================
 def is_enum_class(name: str) -> int:
    """检查类名是否为已注册枚举，返回 1=是 / 0=否（委托到 gen.is_enum_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.is_enum_class(name)
@@ -177,7 +160,6 @@ def is_enum_class(name: str) -> int:
 # ============================================================
 def get_enum_base_type(enum_name: str) -> llvmlite.LLVMType | t.CPtr:
    """按枚举类名获取基准类型（委托到 gen.get_enum_base_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_enum_base_type(enum_name)
@@ -23,6 +23,7 @@ import lib.core.StubMerger as StubMerger
 import lib.core.VLogger as VLogger
 import lib.Projectrans.Config as Config
 import lib.Projectrans.Utils as Utils
+import lib.core.Gen.Generator as Generator


 # ============================================================
@@ -40,18 +41,8 @@ import lib.Projectrans.Utils as Utils

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


 # ============================================================
@@ -65,7 +56,6 @@ def set_global_gen(gen: t.CVoid | t.CPtr) -> None:
 # ============================================================
 def get_func_name(func_node: ast.AST | t.CPtr) -> str:
    """从函数节点提取函数名（委托到 gen.get_func_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_func_name(func_node)
@@ -78,7 +68,6 @@ def get_func_name(func_node: ast.AST | t.CPtr) -> str:
 def escape_llvm_string(pool: memhub.MemBuddy | t.CPtr,
                       src: str) -> str:
    """将字符串转换为 LLVM IR 字符串字面量 c"...\\00"（委托到 gen.escape_llvm_string）"""
-    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.escape_llvm_string(pool, src)
@@ -90,7 +79,6 @@ def escape_llvm_string(pool: memhub.MemBuddy | t.CPtr,
 # ============================================================
 def get_llvm_type_bits(ty: llvmlite.LLVMType | t.CPtr) -> int:
    """获取 LLVM 整数类型的位宽，非整数类型返回 0（委托到 gen.get_llvm_type_bits）"""
-    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_llvm_type_bits(ty)
@@ -102,7 +90,6 @@ def get_llvm_type_bits(ty: llvmlite.LLVMType | t.CPtr) -> int:
 # ============================================================
 def get_llvm_float_bits(ty: llvmlite.LLVMType | t.CPtr) -> int:
    """获取 LLVM 浮点类型的位宽，非浮点类型返回 0（委托到 gen.get_llvm_float_bits）"""
-    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_llvm_float_bits(ty)
@@ -116,7 +103,6 @@ def get_llvm_float_bits(ty: llvmlite.LLVMType | t.CPtr) -> int:
 # ============================================================
 def is_ptr_type(ty: llvmlite.LLVMType | t.CPtr) -> int:
    """检查 ty 是否是 Ptr 类型，返回 1=是, 0=否（委托到 gen.is_ptr_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_ptr_type(ty)
@@ -134,7 +120,6 @@ def is_ptr_type(ty: llvmlite.LLVMType | t.CPtr) -> int:
 # ============================================================
 def get_ptr_level(ty: llvmlite.LLVMType | t.CPtr) -> int:
    """计算指针层级，0=非指针, 1=一级指针, 2=二级指针...（委托到 gen.get_ptr_level）"""
-    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_ptr_level(ty)
@@ -148,7 +133,6 @@ def get_ptr_level(ty: llvmlite.LLVMType | t.CPtr) -> int:
 # ============================================================
 def is_array_type(ty: llvmlite.LLVMType | t.CPtr) -> int:
    """检查 ty 是否是 Array 类型，返回 1=是, 0=否（委托到 gen.is_array_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_array_type(ty)
@@ -165,7 +149,6 @@ def is_array_type(ty: llvmlite.LLVMType | t.CPtr) -> int:
 def _zext_index_to_i32(builder: llvmlite.IRBuilder | t.CPtr,
                       idx_val: llvmlite.Value | t.CPtr) -> llvmlite.Value | t.CPtr:
    """将 <32 位整数下标零扩展到 i32（数组下标非负语义）（委托到 gen._zext_index_to_i32）"""
-    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._zext_index_to_i32(builder, idx_val)
@@ -182,7 +165,6 @@ def _zext_index_to_i32(builder: llvmlite.IRBuilder | t.CPtr,
 def _get_custom_struct_cls_nm(pool: memhub.MemBuddy | t.CPtr,
                              ty: llvmlite.LLVMType | t.CPtr) -> str:
    """检查 ty 或 ty 的 pointee 是否是已注册的自定义结构体，返回类名或 None（委托到 gen._get_custom_struct_cls_nm）"""
-    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_custom_struct_cls_nm(pool, ty)
@@ -196,7 +178,6 @@ def _is_list_subscript_base(pool: memhub.MemBuddy | t.CPtr,
                            trans: HT.Translator | t.CPtr,
                            sub_node: ast.AST | t.CPtr) -> int:
    """判断下标基座是否为 list[T] 变量（1=是）（委托到 gen._is_list_subscript_base）"""
-    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_list_subscript_base(pool, trans, sub_node)
@@ -210,7 +191,6 @@ def _sub_base_class_name(pool: memhub.MemBuddy | t.CPtr,
                         trans: HT.Translator | t.CPtr,
                         sub_node: ast.AST | t.CPtr) -> str:
    """解析下标基座变量的结构体类名（无则 None）（委托到 gen._sub_base_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._sub_base_class_name(pool, trans, sub_node)
@@ -225,7 +205,6 @@ def _sub_base_uses_getitem(pool: memhub.MemBuddy | t.CPtr,
                           trans: HT.Translator | t.CPtr,
                           sub_node: ast.AST | t.CPtr) -> int:
    """下标基座应走 __getitem__ 语义时返回 1，否则 0（应走 GEP 地址语义）（委托到 gen._sub_base_uses_getitem）"""
-    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._sub_base_uses_getitem(pool, mod, trans, sub_node)
@@ -238,7 +217,6 @@ def _sub_base_uses_getitem(pool: memhub.MemBuddy | t.CPtr,
 def _deref_if_ptr_ptr(builder: llvmlite.IRBuilder | t.CPtr,
                      obj_ptr: llvmlite.Value | t.CPtr) -> llvmlite.Value | t.CPtr:
    """如果 obj_ptr 是 Ptr(Ptr(...))，load 解引用获取内层指针（委托到 gen._deref_if_ptr_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._deref_if_ptr_ptr(builder, obj_ptr)
@@ -253,7 +231,6 @@ def coerce_to_type(builder: llvmlite.IRBuilder | t.CPtr,
                   target_ty: llvmlite.LLVMType | t.CPtr,
                   node: ast.AST | t.CPtr = None) -> llvmlite.Value | t.CPtr:
    """将 val 强制转换为 target_ty（委托到 gen.coerce_to_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.coerce_to_type(builder, val, target_ty, node)
@@ -272,7 +249,6 @@ def translate_ptr_arith(pool: memhub.MemBuddy | t.CPtr,
                        int_val: llvmlite.Value | t.CPtr,
                        op: int) -> llvmlite.Value | t.CPtr:
    """指针算术: ptr + int / ptr - int → GEP（按元素大小缩放索引）（委托到 gen.translate_ptr_arith）"""
-    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.translate_ptr_arith(pool, builder, ptr_val, int_val, op)
@@ -288,7 +264,6 @@ def create_global_string(builder: llvmlite.IRBuilder | t.CPtr,
                         str_val: str,
                         trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr:
    """创建全局字符串常量并返回 i8* bitcast（委托到 gen.create_global_string）"""
-    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.create_global_string(builder, pool, mod, str_val, trans)
@@ -306,7 +281,6 @@ def attr_module_path_str(pool: memhub.MemBuddy | t.CPtr,
    跨 mixin 委托：CallGenMixin 等不能 self. 直接调用 ExprGenMixin 的方法
    （@t.NoVTable 静态绑定会 mangle 成当前类名 → undefined reference）。
    """
-    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._attr_module_path_str(pool, node)
@@ -322,7 +296,6 @@ def translate_constant(builder: llvmlite.IRBuilder | t.CPtr,
                       node: ast.AST | t.CPtr,
                       trans: HT.Translator | t.CPtr = None) -> llvmlite.Value | t.CPtr:
    """翻译常量（int/str/bool）（委托到 gen.translate_constant）"""
-    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.translate_constant(builder, pool, mod, node, trans)
@@ -335,7 +308,6 @@ def translate_constant(builder: llvmlite.IRBuilder | t.CPtr,
 def _infer_elem_type_from_value(pool: memhub.MemBuddy | t.CPtr,
                                value: llvmlite.Value | t.CPtr) -> str:
    """从 LLVM Value 的类型推断 list 元素类型名（委托到 gen._infer_elem_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._infer_elem_type_from_value(pool, value)
@@ -349,7 +321,6 @@ def _infer_elem_type_from_value(pool: memhub.MemBuddy | t.CPtr,
 # ============================================================
 def _find_pool_var(trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr:
    """查找上下文中的 pool 变量，返回 alloca 或 None（委托到 gen._find_pool_var）"""
-    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_pool_var(trans)
@@ -368,7 +339,6 @@ def translate_list_literal(builder: llvmlite.IRBuilder | t.CPtr,
                           elem_type_name: str,
                           trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr:
    """翻译 list 字面量 [a, b, c] → list[T](pool) + append 序列（委托到 gen.translate_list_literal）"""
-    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.translate_list_literal(builder, pool, mod, node, elem_type_name, trans)
@@ -386,7 +356,6 @@ def translate_value(builder: llvmlite.IRBuilder | t.CPtr,
                    func_count: int = 0,
                    trans: HT.Translator | t.CPtr = None) -> llvmlite.Value | t.CPtr:
    """翻译值表达式为 LLVM Value（委托到 gen.translate_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.translate_value(builder, pool, mod, node, funcs_ptr, func_count, trans)
@@ -406,7 +375,6 @@ def translate_lambda(builder: llvmlite.IRBuilder | t.CPtr,
                     node: ast.AST | t.CPtr,
                     trans: HT.Translator | t.CPtr = None) -> llvmlite.Value | t.CPtr:
    """翻译 lambda 表达式，返回闭包指针（i8*）（委托到 gen.translate_lambda）"""
-    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.translate_lambda(builder, pool, mod, node, trans)
@@ -422,7 +390,6 @@ def translate_ifexp(builder: llvmlite.IRBuilder | t.CPtr,
                    node: ast.AST | t.CPtr,
                    trans: HT.Translator | t.CPtr = None) -> llvmlite.Value | t.CPtr:
    """翻译三元表达式 (body if test else orelse)，返回 phi 结果 Value（委托到 gen.translate_ifexp）"""
-    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.translate_ifexp(builder, pool, mod, node, trans)
@@ -437,7 +404,6 @@ def should_zext_widen(pool: memhub.MemBuddy | t.CPtr,
                      wide_val: llvmlite.Value | t.CPtr,
                      narrow_node: ast.AST | t.CPtr = None) -> int:
    """判断整数拓宽方向：1=zext（无符号语义），0=sext（委托到 gen.should_zext_widen）"""
-    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.should_zext_widen(pool, narrow_val, wide_val, narrow_node)
@@ -448,7 +414,6 @@ def _node_type_unsigned(pool: memhub.MemBuddy | t.CPtr,
                        node: ast.AST | t.CPtr,
                        trans: HT.Translator | t.CPtr = None) -> int:
    """轻量判断 AST 节点是否解析为无符号整数类型（1=是，0=否/未知）（委托到 gen._node_type_unsigned）"""
-    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._node_type_unsigned(pool, node, trans)
@@ -457,7 +422,6 @@ def _node_type_unsigned(pool: memhub.MemBuddy | t.CPtr,

 def _type_name_unsigned(type_name: str) -> int:
    """类型名是否为无符号整数类型（精确匹配，避免子串误伤如 nUIntCount）（委托到 gen._type_name_unsigned）"""
-    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._type_name_unsigned(type_name)
@@ -470,7 +434,6 @@ def translate_compare(builder: llvmlite.IRBuilder | t.CPtr,
                      node: ast.AST | t.CPtr,
                      trans: HT.Translator | t.CPtr = None) -> llvmlite.Value | t.CPtr:
    """翻译比较表达式，返回 i1 结果（委托到 gen.translate_compare）"""
-    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.translate_compare(builder, pool, mod, node, trans)
@@ -486,7 +449,6 @@ def translate_unaryop(builder: llvmlite.IRBuilder | t.CPtr,
                      node: ast.AST | t.CPtr,
                      trans: HT.Translator | t.CPtr = None) -> llvmlite.Value | t.CPtr:
    """翻译一元运算（-x, +x, not x, ~x）（委托到 gen.translate_unaryop）"""
-    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.translate_unaryop(builder, pool, mod, node, trans)
@@ -504,7 +466,6 @@ def translate_boolop(builder: llvmlite.IRBuilder | t.CPtr,
                     func_count: int = 0,
                     trans: HT.Translator | t.CPtr = None) -> llvmlite.Value | t.CPtr:
    """翻译布尔运算（and/or）的短路求值，返回 i1（委托到 gen.translate_boolop）"""
-    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.translate_boolop(builder, pool, mod, node, funcs_ptr, func_count, trans)
@@ -516,7 +477,6 @@ def translate_boolop(builder: llvmlite.IRBuilder | t.CPtr,
 # ============================================================
 def _build_source_path_from_sha1(sha1: str) -> str:
    """通过 SHA1 从全局存储器构建源 .py 文件路径（委托到 gen._build_source_path_from_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._build_source_path_from_sha1(sha1)
@@ -533,7 +493,6 @@ def _lookup_cross_module_cdefine(pool: memhub.MemBuddy | t.CPtr,
                                  depth: int = 0,
                                  node: ast.AST | t.CPtr = None) -> t.CInt64T:
    """跨模块查找 CDefine 常量，返回值（64 位）或 -1（未找到）（委托到 gen._lookup_cross_module_cdefine）"""
-    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_cross_module_cdefine(pool, name, from_imports, imported_modules, depth, node)
@@ -545,7 +504,6 @@ def _lookup_cross_module_cdefine(pool: memhub.MemBuddy | t.CPtr,
 # ============================================================
 def _is_cdefine_name_pattern(name: str) -> int:
    """检查名字是否符合 CDefine 命名约定（全大写+下划线+数字）（委托到 gen._is_cdefine_name_pattern）"""
-    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_cdefine_name_pattern(name)
@@ -560,7 +518,6 @@ def translate_name_value(builder: llvmlite.IRBuilder | t.CPtr,
                         node: ast.AST | t.CPtr,
                         trans: HT.Translator | t.CPtr = None) -> llvmlite.Value | t.CPtr:
    """翻译变量引用（Name 节点）→ load（委托到 gen.translate_name_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.translate_name_value(builder, pool, node, trans)
@@ -616,7 +573,6 @@ def list_getitem_inline(builder: llvmlite.IRBuilder | t.CPtr,
                        idx_val: llvmlite.Value | t.CPtr,
                        node: ast.AST | t.CPtr = None) -> llvmlite.Value | t.CPtr:
    """内联生成 list __getitem__ 逻辑，返回元素地址 (i8*)（委托到 gen.list_getitem_inline）"""
-    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.list_getitem_inline(builder, pool, lm_obj, idx_val, node)
@@ -629,7 +585,6 @@ def list_getitem_inline(builder: llvmlite.IRBuilder | t.CPtr,
 def _list_elem_type_from_name(pool: memhub.MemBuddy | t.CPtr,
                              struct_name: str) -> llvmlite.LLVMType | t.CPtr:
    """从 list 类型名提取元素 LLVM 类型（委托到 gen._list_elem_type_from_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._list_elem_type_from_name(pool, struct_name)
@@ -646,7 +601,6 @@ def list_setitem_inline(builder: llvmlite.IRBuilder | t.CPtr,
                        rhs_val: llvmlite.Value | t.CPtr,
                        node: ast.AST | t.CPtr = None) -> int:
    """内联生成 list __setitem__ 逻辑，返回 0（委托到 gen.list_setitem_inline）"""
-    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.list_setitem_inline(builder, pool, lm_obj, idx_val, rhs_val, node)
@@ -661,7 +615,6 @@ def list_setitem_inline(builder: llvmlite.IRBuilder | t.CPtr,
 def is_list_subscript(node: ast.AST | t.CPtr,
                      trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr:
    """检查 Subscript 节点是否是 list[T] 类型，返回 list 对象指针或 None（委托到 gen.is_list_subscript）"""
-    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_list_subscript(node, trans)
@@ -677,7 +630,6 @@ def translate_subscript(builder: llvmlite.IRBuilder | t.CPtr,
                        node: ast.AST | t.CPtr,
                        trans: HT.Translator | t.CPtr = None) -> llvmlite.Value | t.CPtr:
    """翻译下标表达式，返回加载的元素值（委托到 gen.translate_subscript）"""
-    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.translate_subscript(builder, pool, mod, node, trans)
@@ -694,7 +646,6 @@ def translate_subscript(builder: llvmlite.IRBuilder | t.CPtr,
 def find_global_in_module(mod: llvmlite.LLVMModule | t.CPtr,
                          name: str) -> llvmlite.GlobalVariable | t.CPtr:
    """在模块全局变量链表中按名称查找全局变量（委托到 gen.find_global_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:
        return g.find_global_in_module(mod, name)
@@ -708,7 +659,6 @@ def make_global_ref(pool: memhub.MemBuddy | t.CPtr,
                    name: str,
                    ty: llvmlite.LLVMType | t.CPtr) -> llvmlite.Value | t.CPtr:
    """创建全局变量引用 (类型为 ty*，名称为 @name)（委托到 gen.make_global_ref）"""
-    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.make_global_ref(pool, name, ty)
@@ -720,7 +670,6 @@ def make_global_ref(pool: memhub.MemBuddy | t.CPtr,
 # ============================================================
 def _is_t_type_object_name(name: str) -> int:
    """检查 name 是否是 t.py 中的类型对象名（CPtr/CInt/CDouble 等）（委托到 gen._is_t_type_object_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_t_type_object_name(name)
@@ -736,7 +685,6 @@ def _resolve_module_attribute_global(pool: memhub.MemBuddy | t.CPtr,
                                     at: ast.Attribute | t.CPtr,
                                     ty_hint: llvmlite.LLVMType | t.CPtr) -> llvmlite.Value | t.CPtr:
    """解析模块属性访问，返回全局变量引用 (用于跨模块 global 访问)（委托到 gen._resolve_module_attribute_global）"""
-    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._resolve_module_attribute_global(pool, mod, trans, at, ty_hint)
@@ -752,7 +700,6 @@ def _get_cderef_attr_base(builder: llvmlite.IRBuilder | t.CPtr,
                          at_value: ast.AST | t.CPtr,
                          trans: HT.Translator | t.CPtr = None) -> llvmlite.Value | t.CPtr:
    """检测 at.value 是否为 c.Deref(ptr) 调用，返回 ptr 指针（不做 load）（委托到 gen._get_cderef_attr_base）"""
-    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_cderef_attr_base(builder, pool, mod, at_value, trans)
@@ -768,7 +715,6 @@ def translate_attribute(builder: llvmlite.IRBuilder | t.CPtr,
                        node: ast.AST | t.CPtr,
                        trans: HT.Translator | t.CPtr = None) -> llvmlite.Value | t.CPtr:
    """翻译属性访问，返回加载的字段值（委托到 gen.translate_attribute）"""
-    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.translate_attribute(builder, pool, mod, node, trans)
@@ -784,7 +730,6 @@ def get_subscript_ptr(builder: llvmlite.IRBuilder | t.CPtr,
                      node: ast.AST | t.CPtr,
                      trans: HT.Translator | t.CPtr = None) -> llvmlite.Value | t.CPtr:
    """获取下标表达式的元素指针（用于赋值 lhs）（委托到 gen.get_subscript_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_subscript_ptr(builder, pool, mod, node, trans)
@@ -800,7 +745,6 @@ def get_attribute_ptr(builder: llvmlite.IRBuilder | t.CPtr,
                      node: ast.AST | t.CPtr,
                      trans: HT.Translator | t.CPtr = None) -> llvmlite.Value | t.CPtr:
    """获取属性访问的字段指针（用于赋值 lhs）（委托到 gen.get_attribute_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_attribute_ptr(builder, pool, mod, node, trans)
@@ -816,7 +760,6 @@ def translate_joined_str(builder: llvmlite.IRBuilder | t.CPtr,
                         node: ast.AST | t.CPtr,
                         trans: HT.Translator | t.CPtr = None) -> llvmlite.Value | t.CPtr:
    """翻译 f-string（委托到 gen.translate_joined_str，定义于 ExprGenFstr）"""
-    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.translate_joined_str(builder, pool, mod, node, trans)
@@ -832,7 +775,6 @@ def translate_formatted_value(builder: llvmlite.IRBuilder | t.CPtr,
                              node: ast.AST | t.CPtr,
                              trans: HT.Translator | t.CPtr = None) -> llvmlite.Value | t.CPtr:
    """翻译裸 FormattedValue（委托到 gen.translate_formatted_value，定义于 ExprGenFstr）"""
-    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.translate_formatted_value(builder, pool, mod, node, trans)
@@ -845,7 +787,6 @@ def translate_formatted_value(builder: llvmlite.IRBuilder | t.CPtr,
 def _const_int_for_cdefine(pool: memhub.MemBuddy | t.CPtr,
                           value: t.CInt64T) -> llvmlite.Value | t.CPtr:
    """CDefine 整数常量 → LLVM 常量（委托到 gen._const_int_for_cdefine，定义于 ExprGenCdef）"""
-    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._const_int_for_cdefine(pool, value)
@@ -859,7 +800,6 @@ def _resolve_doc_symbol_attr(trans: HT.Translator | t.CPtr,
                             at: ast.Attribute | t.CPtr,
                             out_mod: str | t.CPtr, out_sym: str | t.CPtr) -> int:
    """解析嵌套 Attribute 链的 docstring 归属（委托到 gen._resolve_doc_symbol_attr，定义于 ExprGenCls）"""
-    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._resolve_doc_symbol_attr(trans, at, out_mod, out_sym)
@@ -872,7 +812,6 @@ def _resolve_doc_symbol_attr(trans: HT.Translator | t.CPtr,
 def _resolve_doc_symbol_name(trans: HT.Translator | t.CPtr, name_id: str,
                             out_mod: str | t.CPtr, out_sym: str | t.CPtr) -> int:
    """解析 Name 符号的 docstring 归属（委托到 gen._resolve_doc_symbol_name，定义于 ExprGenCls）"""
-    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._resolve_doc_symbol_name(trans, name_id, out_mod, out_sym)
@@ -884,7 +823,6 @@ def _resolve_doc_symbol_name(trans: HT.Translator | t.CPtr, name_id: str,
 # ============================================================
 def lookup_docstring(module_sha1: str, symbol: str) -> str:
    """查找 docstring 内容（委托到 gen.lookup_docstring，定义于 ExprGenCls）"""
-    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_docstring(module_sha1, symbol)
@@ -898,7 +836,6 @@ def _resolve_attr_field_class(pool: memhub.MemBuddy | t.CPtr,
                              trans: HT.Translator | t.CPtr,
                              attr_node: ast.AST | t.CPtr) -> str:
    """解析属性链最终字段的注解类名（委托到 gen._resolve_attr_field_class，定义于 ExprGenAttr）"""
-    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._resolve_attr_field_class(pool, trans, attr_node)
@@ -914,7 +851,6 @@ def translate_binop(pool: memhub.MemBuddy | t.CPtr,
                    node: ast.AST | t.CPtr,
                    trans: HT.Translator | t.CPtr = None) -> llvmlite.Value | t.CPtr:
    """翻译二元运算（委托到 gen.translate_binop，定义于 ExprGenOps）"""
-    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.translate_binop(pool, builder, mod, node, trans)
@@ -926,7 +862,6 @@ def translate_binop(pool: memhub.MemBuddy | t.CPtr,
 # ============================================================
 def _binop_to_dunder(op: int) -> str:
    """binop op → dunder 方法名（委托到 gen._binop_to_dunder，定义于 ExprGenOps）"""
-    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._binop_to_dunder(op)
@@ -938,7 +873,6 @@ def _binop_to_dunder(op: int) -> str:
 # ============================================================
 def _unaryop_to_dunder(op: int) -> str:
    """unaryop op → dunder 方法名（委托到 gen._unaryop_to_dunder，定义于 ExprGenOps）"""
-    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._unaryop_to_dunder(op)
@@ -957,7 +891,6 @@ def _fstr_finalize(builder: llvmlite.IRBuilder | t.CPtr,
                   arg_count: int,
                   trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr:
    """f-string 尾部（委托到 gen._fstr_finalize，定义于 ExprGenFstr）"""
-    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._fstr_finalize(builder, pool, mod, fmt_buf, arg_head, arg_tail, arg_count, trans)
@@ -969,7 +902,6 @@ def _fstr_finalize(builder: llvmlite.IRBuilder | t.CPtr,
 # ============================================================
 def _fstr_append_literal(fmt_buf: str, lit: str) -> None:
    """追加字面量到格式串（委托到 gen._fstr_append_literal，定义于 ExprGenFstr）"""
-    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._fstr_append_literal(fmt_buf, lit)
@@ -983,7 +915,6 @@ def _fstr_parse_format_spec(pool: memhub.MemBuddy | t.CPtr,
                            val: llvmlite.Value | t.CPtr,
                            arg_node: ast.AST | t.CPtr) -> str:
    """Python format_spec → C printf 格式串（委托到 gen._fstr_parse_format_spec，定义于 ExprGenFstr）"""
-    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._fstr_parse_format_spec(pool, spec_node, val, arg_node)
@@ -998,7 +929,6 @@ def _fstr_infer_c_fmt(pool: memhub.MemBuddy | t.CPtr,
                      arg_node: ast.AST | t.CPtr,
                      trans: HT.Translator | t.CPtr) -> str:
    """按值类型推断 C printf 格式（委托到 gen._fstr_infer_c_fmt，定义于 ExprGenFstr）"""
-    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._fstr_infer_c_fmt(pool, val, arg_node, trans)
@@ -1015,7 +945,6 @@ def _fstr_cast_value(builder: llvmlite.IRBuilder | t.CPtr,
                     arg_node: ast.AST | t.CPtr,
                     trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr:
    """按 C 格式转换值类型（委托到 gen._fstr_cast_value，定义于 ExprGenFstr）"""
-    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._fstr_cast_value(builder, pool, val, c_fmt, arg_node, trans)
@@ -21,22 +21,12 @@ import lib.core.Handles.HandlesImports as HandlesImports
 import lib.core.Handles.HandlesClassDef as HandlesClassDef
 import lib.core.StubMerger as StubMerger
 import lib.core.Handles.ExprCallCall as ExprCallCall
-
+import lib.core.Gen.Generator as Generator

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


 # ============================================================
@@ -55,25 +45,6 @@ MAX_FUNC_PTR_SIGS: t.CDefine = 64
 GLOBAL_FUNC_MAX: t.CDefine = 8192
 GLOBAL_DEFAULTS_MAX: t.CDefine = 4096

-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-


 # ============================================================
@@ -91,90 +62,6 @@ class AsmOperand:



-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 # ============================================================
 # FuncEntry 结构体（用于函数表）
 # ============================================================
@@ -195,15 +82,6 @@ class FuncEntry:



-
-
-
-
-
-
-
-
-
@t.NoVTable
 class FuncDefaultsEntry:
    """默认参数表条目"""
@@ -8,7 +8,7 @@ import viperlib
 import lib.core.Handles.HandlesExpr as HandlesExpr
 import lib.core.Handles.HandlesVar as HandlesVar
 import lib.core.Handles.HandlesTranslator as HT
-
+import lib.core.Gen.Generator as Generator

 # ============================================================
 # HandlesExprOps - 二元运算处理（P3 对象化后的委托层）
@@ -22,18 +22,8 @@ import lib.core.Handles.HandlesTranslator as HT

 # ============================================================
 # 全局 gen 单例（模块级镜像，同 HandlesType/HandlesStruct 模式）
-#
-# 由 BuildPipeline/main 在 gen 创建后调用 set_global_gen 注入。
-# P3 委托函数用本地 _g_gen（cast 成 Generator 类型）调
-# ExprGenMixin 方法。
 # ============================================================
-_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
+_g_gen: Generator.Generator | t.CPtr = None


 # ============================================================
@@ -45,7 +35,6 @@ def set_global_gen(gen: t.CVoid | t.CPtr) -> None:
 # BinOp 运算符 → dunder 方法名
 def _binop_to_dunder(op: int) -> str:
    """将 BinOp 运算符映射到 dunder 方法名，无映射时返回 None（委托到 gen._binop_to_dunder）"""
-    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._binop_to_dunder(op)
@@ -55,7 +44,6 @@ def _binop_to_dunder(op: int) -> str:
 # Compare 运算符 → dunder 方法名
 def _cmpop_to_dunder(op: int) -> str:
    """将 Compare 运算符映射到 dunder 方法名，无映射时返回 None（委托到 gen._cmpop_to_dunder）"""
-    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._cmpop_to_dunder(op)
@@ -65,7 +53,6 @@ def _cmpop_to_dunder(op: int) -> str:
 # UnaryOp 运算符 → dunder 方法名
 def _unaryop_to_dunder(op: int) -> str:
    """将 UnaryOp 运算符映射到 dunder 方法名，无映射时返回 None（委托到 gen._unaryop_to_dunder）"""
-    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._unaryop_to_dunder(op)
@@ -88,7 +75,6 @@ def try_operator_overload(pool: memhub.MemBuddy | t.CPtr,
                          trans: HT.Translator | t.CPtr,
                          is_compare: int) -> llvmlite.Value | t.CPtr:
    """尝试运算符重载：lhs 是结构体指针时调用 dunder 方法，否则返回 None（委托到 gen.try_operator_overload）"""
-    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.try_operator_overload(pool, builder, mod, lhs, rhs, op, trans, is_compare)
@@ -109,7 +95,6 @@ def try_unary_operator_overload(pool: memhub.MemBuddy | t.CPtr,
                                op: int,
                                trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr:
    """尝试一元运算符重载：operand 是结构体指针时调用 dunder 方法，否则返回 None（委托到 gen.try_unary_operator_overload）"""
-    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.try_unary_operator_overload(pool, builder, mod, operand, op, trans)
@@ -125,7 +110,6 @@ def translate_binop(pool: memhub.MemBuddy | t.CPtr,
                    node: ast.AST | t.CPtr,
                    trans: HT.Translator | t.CPtr = None) -> llvmlite.Value | t.CPtr:
    """翻译二元运算（自动类型提升）（委托到 gen.translate_binop）"""
-    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.translate_binop(pool, builder, mod, node, trans)
@@ -17,6 +17,7 @@ import lib.core.Handles.HandlesType as HandlesType
 import lib.core.Handles.HandlesExprCall as HandlesExprCall
 import lib.core.Handles.HandlesStruct as HandlesStruct
 import lib.core.Handles.ExprCallBase as ExprCallBase
+import lib.core.Gen.Generator as Generator


 # ============================================================
@@ -53,7 +54,7 @@ import lib.core.Handles.ExprCallBase as ExprCallBase
 # 委托函数用本地 _g_gen（cast 成 Generator 类型）调
 # StmtGenMixin 方法，避免函数体 import 包模块与类/模块名歧义。
 # ============================================================
-_g_gen: t.CVoid | t.CPtr = None
+_g_gen: Generator.Generator | t.CPtr = None


 # ============================================================
@@ -67,12 +68,6 @@ SEQ_KIND_STR: t.CDefine = 2
 SEQ_KIND_LIST: t.CDefine = 3


-def set_global_gen(gen: t.CVoid | t.CPtr) -> None:
-    """注入全局 gen 单例（BuildPipeline/main 调用）"""
-    global _g_gen
-    _g_gen = gen
-
-
@t.NoVTable
 class ForHandle(ForHandleBase.ForHandleBase, ForHandleIter.ForHandleIter):
    """for 循环语句处理器：继承 Mixin 获得 Trans 回指针"""
@@ -427,21 +422,12 @@ class ForHandle(ForHandleBase.ForHandleBase, ForHandleIter.ForHandleIter):



-
-
-
-
-
-
-
-
 # ============================================================
 # NewForHandle - 工厂函数（委托到 gen.NewForHandle）
 # ============================================================
 def NewForHandle(pool: memhub.MemBuddy | t.CPtr,
                 trans: HT.Translator | t.CPtr) -> ForHandle | t.CPtr:
    """创建 ForHandle 实例（委托到 gen.NewForHandle）"""
-    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.NewForHandle(pool, trans)
@@ -16,6 +16,7 @@ import lib.core.Handles.HandlesExpr as HandlesExpr
 import lib.core.Handles.HandlesBody as HandlesBody
 import lib.core.Handles.HandlesNonlocal as HandlesNonlocal
 import lib.core.Handles.HandlesImports as HandlesImports
+import lib.core.Gen.Generator as Generator


 # ============================================================
@@ -31,18 +32,8 @@ import lib.core.Handles.HandlesImports as HandlesImports

 # ============================================================
 # 全局 gen 单例（模块级镜像）
-#
-# 由 BuildPipeline/main 在 gen 创建后调用 set_global_gen 注入。
-# 委托函数用本地 _g_gen（cast 成 Generator 类型），避免函数体
-# import 包模块（TPC 不注册包短名）与 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
+_g_gen: Generator.Generator | t.CPtr = None


 # 作用域类型常量（本地副本，避免旧编译器跨模块 CDefine 查找 bug）
@@ -59,7 +50,6 @@ def extract_func_attrs(pool: memhub.MemBuddy | t.CPtr,
                       decorator_list: list[ast.AST | t.CPtr] | t.CPtr,
                       imported_modules: str) -> str:
    """从 decorator_list 提取 c.Attribute 属性，返回 LLVM IR 属性字符串（委托到 gen.extract_func_attrs）"""
-    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_func_attrs(pool, decorator_list, imported_modules)
@@ -68,7 +58,6 @@ def extract_func_attrs(pool: memhub.MemBuddy | t.CPtr,

 def _get_attr_name_from_node(node: ast.AST | t.CPtr) -> str:
    """从 AST 节点提取属性名（委托到 gen._get_attr_name_from_node）"""
-    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_attr_name_from_node(node)
@@ -77,7 +66,6 @@ def _get_attr_name_from_node(node: ast.AST | t.CPtr) -> str:

 def _append_llvm_attr(attrs_buf: str, attr_name: str) -> int:
    """将属性名映射到 LLVM 属性名并追加到缓冲区（委托到 gen._append_llvm_attr）"""
-    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._append_llvm_attr(attrs_buf, attr_name)
@@ -86,7 +74,6 @@ def _append_llvm_attr(attrs_buf: str, attr_name: str) -> int:

 def _append_str(buf: str, s: str) -> None:
    """将字符串追加到 buf 末尾（用 strlen+strcpy 模拟 strcat）（委托到 gen._append_str）"""
-    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._append_str(buf, s)
@@ -94,7 +81,6 @@ def _append_str(buf: str, s: str) -> None:

 def _mangle_name(trans: HT.Translator | t.CPtr, name: str) -> str:
    """为任意名称添加 SHA1 前缀（不做 main/export 检查）（委托到 gen._mangle_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._mangle_name(trans, name)
@@ -103,7 +89,6 @@ def _mangle_name(trans: HT.Translator | t.CPtr, name: str) -> str:

 def _mangle_name_with_sha1(sha1: str, name: str) -> str:
    """用指定 SHA1 为名称添加前缀（不做 main/export 检查）（委托到 gen._mangle_name_with_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._mangle_name_with_sha1(sha1, name)
@@ -113,7 +98,6 @@ def _mangle_name_with_sha1(sha1: str, name: str) -> str:
 def _mangle_func_name(trans: HT.Translator | t.CPtr, name: str,
                      has_export: int) -> str:
    """为函数名添加 SHA1 前缀（检查 main/export）（委托到 gen._mangle_func_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._mangle_func_name(trans, name, has_export)
@@ -123,7 +107,6 @@ def _mangle_func_name(trans: HT.Translator | t.CPtr, name: str,
 def forward_declare_functions(trans: HT.Translator | t.CPtr,
                              tree: ast.AST | t.CPtr) -> int:
    """预扫描所有顶层 FunctionDef，创建前向声明（委托到 gen.forward_declare_functions）"""
-    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.forward_declare_functions(trans, tree)
@@ -133,7 +116,6 @@ def forward_declare_functions(trans: HT.Translator | t.CPtr,
 def translate_function_def(trans: HT.Translator | t.CPtr,
                           node: ast.AST | t.CPtr) -> int:
    """翻译函数定义，返回新增的变量数（通常为 0，函数定义不增加当前作用域变量）（委托到 gen.translate_function_def）"""
-    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.translate_function_def(trans, node)
@@ -143,7 +125,6 @@ def translate_function_def(trans: HT.Translator | t.CPtr,
 def translate_nested_function_def(trans: HT.Translator | t.CPtr,
                                  node: ast.AST | t.CPtr) -> int:
    """翻译嵌套函数定义：提升为顶层函数 + 创建闭包（委托到 gen.translate_nested_function_def）"""
-    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.translate_nested_function_def(trans, node)
@@ -156,7 +137,6 @@ def create_function(pool: memhub.MemBuddy | t.CPtr,
                    args_node: ast.AST | t.CPtr,
                    ret_ty: llvmlite.LLVMType | t.CPtr) -> llvmlite.Function | t.CPtr:
    """创建 LLVM 函数并添加参数（委托到 gen.create_function）"""
-    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.create_function(pool, mod, name, args_node, ret_ty)
@@ -13,6 +13,7 @@ import lib.core.Handles.HandlesBody as HandlesBody
 import lib.core.Handles.HandlesType as HandlesType
 import lib.core.Handles.HandlesImports as HandlesImports
 import lib.Projectrans.Config as Config
+import lib.core.Gen.Generator as Generator


 # ============================================================
@@ -45,23 +46,12 @@ _g_cif_eval_ok: int = 0

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


 def _is_cif_attr(attr: str) -> int:
    """检查方法名是否为 CIf 系（CIf/CIfdef/CIfndef）（委托到 gen._is_cif_attr）"""
-    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_cif_attr(attr)
@@ -70,7 +60,6 @@ def _is_cif_attr(attr: str) -> int:

 def _is_cif_call(node: ast.AST | t.CPtr) -> int:
    """检查 test 是否为 c.CIf(...)/c.CIfdef(...)/c.CIfndef(...)（或裸 CIf 系）调用（委托到 gen._is_cif_call）"""
-    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_cif_call(node)
@@ -83,7 +72,6 @@ def _get_platform_macro_value(name: str) -> int:
    命中置 _g_cif_eval_ok=1；未命中置 0 返回 0（委托到 gen._get_platform_macro_value）。
    """
    global _g_cif_eval_ok
-    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:
        v: int = g._get_platform_macro_value(name)
@@ -100,7 +88,6 @@ def _cif_name_value(pool: memhub.MemBuddy | t.CPtr,
    命中置 _g_cif_eval_ok=1（值 0 也算命中，如 DISABLED=0）；未命中置 0（委托到 gen._cif_name_value）。
    """
    global _g_cif_eval_ok
-    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:
        v: int = g._cif_name_value(pool, trans, name)
@@ -117,7 +104,6 @@ def _cif_attr_value(pool: memhub.MemBuddy | t.CPtr,
    命中置 _g_cif_eval_ok=1；未命中置 0（委托到 gen._cif_attr_value）。
    """
    global _g_cif_eval_ok
-    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:
        v: int = g._cif_attr_value(pool, trans, at)
@@ -137,7 +123,6 @@ def _cif_eval_node(pool: memhub.MemBuddy | t.CPtr,
    成功置 _g_cif_eval_ok=1；失败（含运行时变量）置 0 返回 0（委托到 gen._cif_eval_node）。
    """
    global _g_cif_eval_ok
-    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:
        v: int = g._cif_eval_node(pool, trans, node)
@@ -155,7 +140,6 @@ def _evaluate_cif_test(pool: memhub.MemBuddy | t.CPtr,
    失败（运行时变量/未知结构）: 置 _g_cif_eval_ok=0，返回 0（委托到 gen._evaluate_cif_test）。
    """
    global _g_cif_eval_ok
-    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:
        v: int = g._evaluate_cif_test(pool, trans, test)
@@ -355,7 +339,6 @@ class IfHandle(HandlesBase.Mixin):
 def NewIfHandle(pool: memhub.MemBuddy | t.CPtr,
                trans: HT.Translator | t.CPtr) -> IfHandle | t.CPtr:
    """创建 IfHandle 实例（委托到 gen.NewIfHandle）"""
-    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.NewIfHandle(pool, trans)
@@ -13,6 +13,7 @@ import lib.core.Handles.HandlesBase as HandlesBase
 import lib.core.Handles.HandlesTranslator as HT
 import lib.core.Handles.HandlesStruct as HandlesStruct
 import lib.core.StubMerger as StubMerger
+import lib.core.Gen.Generator as Generator


 # ============================================================
@@ -42,13 +43,7 @@ MAX_REEXPORT: t.CDefine = 512
 # ImportsGenMixin 方法，避免函数体 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
+_g_gen: Generator.Generator | t.CPtr = None


 # ============================================================
@@ -64,7 +59,6 @@ def add_imported_module(pool: memhub.MemBuddy | t.CPtr,
                        imported_modules: str,
                        name: str) -> str:
    """记录已导入的模块名，返回新的 imported_modules 字符串指针（委托到 gen.add_imported_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.add_imported_module(pool, imported_modules, name)
@@ -76,7 +70,6 @@ def add_imported_module(pool: memhub.MemBuddy | t.CPtr,
 # ============================================================
 def is_module_imported(imported_modules: str, name: str) -> int:
    """检查模块是否已导入（词边界精确匹配，避免子串误匹配，委托到 gen.is_module_imported）"""
-    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_module_imported(imported_modules, name)
@@ -98,7 +91,6 @@ def add_from_import(pool: memhub.MemBuddy | t.CPtr,
        有别名: "local_name:module_name:original_name"
        （original_name 为源模块中的真实函数名，用于跨模块 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.add_from_import(pool, from_imports, local_name, module_name, original_name)
@@ -114,7 +106,6 @@ def add_from_import(pool: memhub.MemBuddy | t.CPtr,
 def lookup_from_import_original(from_imports: str,
                                local_name: str) -> str:
    """查找 from-import 别名对应的原始函数名，返回 None=无别名或未找到（委托到 gen.lookup_from_import_original）"""
-    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_from_import_original(from_imports, local_name)
@@ -136,7 +127,6 @@ def lookup_from_import(from_imports: str, name: str,
    支持 star import: 如果 from_imports 中有 "*:module" 条目，
    且未找到精确名称匹配，且 allow_star_fallback != 0，则返回 star import 的模块名。
    """
-    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_from_import(from_imports, name, allow_star_fallback)
@@ -154,7 +144,6 @@ def lookup_from_import(from_imports: str, name: str,
 # ============================================================
 def register_reexport(mod_sha1: str, func_name: str, source_module: str) -> int:
    """注册 re-export 映射（幂等），返回 0 成功，-1 失败（委托到 gen.register_reexport）"""
-    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_reexport(mod_sha1, func_name, source_module)
@@ -169,7 +158,6 @@ def register_reexport(mod_sha1: str, func_name: str, source_module: str) -> int:
 # ============================================================
 def lookup_reexport(mod_sha1: str, func_name: str) -> str:
    """查找 re-export 映射，返回源模块名或 None（委托到 gen.lookup_reexport）"""
-    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_reexport(mod_sha1, func_name)
@@ -201,7 +189,6 @@ def _resolve_relative_module(pool: memhub.MemBuddy | t.CPtr,
                             level: t.CInt,
                             module: str) -> str:
    """解析相对导入为完整模块名（委托到 gen._resolve_relative_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._resolve_relative_module(pool, current_package, level, module)
@@ -223,7 +210,6 @@ def _resolve_relative_module(pool: memhub.MemBuddy | t.CPtr,
 def compute_package_from_relpath(pool: memhub.MemBuddy | t.CPtr,
                                 rel_path: str) -> str:
    """从相对路径计算包名（目录部分，分隔符替换为 .，委托到 gen.compute_package_from_relpath）"""
-    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.compute_package_from_relpath(pool, rel_path)
@@ -238,7 +224,6 @@ def compute_package_from_relpath(pool: memhub.MemBuddy | t.CPtr,
 # ============================================================
 def set_current_file(file_path: str) -> None:
    """设置当前正在编译的文件名（与 HandlesType.set_current_file 同步调用，委托到 gen.set_current_file）"""
-    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_current_file(file_path)
@@ -255,7 +240,6 @@ def set_current_file(file_path: str) -> None:
 # ============================================================
 def _report_import_error(node: ast.AST | t.CPtr, msg: str) -> None:
    """以 Python 风格报错并退出（本地实现，避免循环依赖，委托到 gen._report_import_error）"""
-    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._report_import_error(node, msg)
@@ -269,7 +253,6 @@ def _report_import_error(node: ast.AST | t.CPtr, msg: str) -> None:
 # ============================================================
 def _is_local_module_file(mod_name: str) -> int:
    """当前文件同目录存在 {mod_name}.vp/.py → 项目内兄弟模块（委托到 gen._is_local_module_file）"""
-    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_local_module_file(mod_name)
@@ -297,7 +280,6 @@ def _check_import_sha1(node: ast.AST | t.CPtr, mod_name: str) -> int:
    Returns:
        1=检查通过；模块未注册时直接报错退出（不会返回 0）
    """
-    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._check_import_sha1(node, mod_name)
@@ -16,6 +16,7 @@ import lib.core.Handles.HandlesFunctions as HandlesFunctions
 import lib.core.Handles.HandlesType as HandlesType
 import lib.core.Handles.HandlesClassDef as HandlesClassDef
 import lib.core.Handles.HandlesAnnAssign as HandlesAnnAssign
+import lib.core.Gen.Generator as Generator


 # ============================================================
@@ -36,18 +37,8 @@ import lib.core.Handles.HandlesAnnAssign as HandlesAnnAssign

 # ============================================================
 # 全局 gen 单例（模块级镜像，同 HandlesType/HandlesStruct 模式）
-#
-# 由 BuildPipeline/main 在 gen 创建后调用 set_global_gen 注入。
-# P6-E 委托函数用本地 _g_gen（cast 成 Generator 类型）调
-# TranslatorGenMixin 方法，避免函数体 import 包模块与类/模块名歧义。
 # ============================================================
-_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
+_g_gen: Generator.Generator | t.CPtr = None


 # ============================================================
@@ -60,7 +51,6 @@ def set_global_gen(gen: t.CVoid | t.CPtr) -> None:
 def _register_cexport_from_funcdef(trans: HT.Translator | t.CPtr,
                                   node: ast.AST | t.CPtr) -> int:
    """预注册 CExport/State 函数到全局表（仅注册，不生成 IR）（委托到 gen._register_cexport_from_funcdef）"""
-    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_cexport_from_funcdef(trans, node)
@@ -84,7 +74,6 @@ def translate_children(trans: HT.Translator | t.CPtr,
    Returns:
        t.CInt: 新增的变量数
    """
-    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.translate_children(trans, tree)
@@ -102,7 +91,6 @@ def translate_children(trans: HT.Translator | t.CPtr,
 def _prescan_funcdef_signatures(trans: HT.Translator | t.CPtr,
                                fd: ast.FunctionDef | t.CPtr) -> None:
    """预解析模块级函数签名的返回/参数类型，触发泛型类特化（委托到 gen._prescan_funcdef_signatures）"""
-    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._prescan_funcdef_signatures(trans, fd)
@@ -118,7 +106,6 @@ def _build_array_initializer_text(pool: memhub.MemBuddy | t.CPtr,
                                  var_ty: llvmlite.LLVMType | t.CPtr,
                                  list_node: ast.List | t.CPtr) -> str:
    """从 AST List 节点生成 LLVM IR 数组初始化器文本，None 失败（委托到 gen._build_array_initializer_text）"""
-    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._build_array_initializer_text(pool, var_ty, list_node)
@@ -137,7 +124,6 @@ def _build_string_ptr_initializer(pool: memhub.MemBuddy | t.CPtr,
                                  var_name: str,
                                  str_val: str) -> str:
    """为字符串字面量创建内部常量全局并返回 GEP 初始化器文本，None 失败（委托到 gen._build_string_ptr_initializer）"""
-    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._build_string_ptr_initializer(pool, mod, var_name, str_val)
@@ -154,7 +140,6 @@ def _build_string_ptr_initializer(pool: memhub.MemBuddy | t.CPtr,
 def handle_module_level_var(trans: HT.Translator | t.CPtr,
                            node: ast.AST | t.CPtr) -> int:
    """处理模块级变量声明，创建全局变量（委托到 gen.handle_module_level_var）"""
-    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.handle_module_level_var(trans, node)
@@ -181,7 +166,6 @@ def create_wrapper_main(trans: HT.Translator | t.CPtr,
    Returns:
        t.CInt: 新增的变量数
    """
-    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.create_wrapper_main(trans, tree, i32_ty)
@@ -13,6 +13,7 @@ import lib.core.Handles.HandlesVar as HandlesVar
 import lib.core.Handles.HandlesClassDef as HandlesClassDef
 import lib.core.Handles.HandlesStruct as HandlesStruct
 import lib.core.Handles.HandlesType as HandlesType
+import lib.core.Gen.Generator as Generator


 # ============================================================
@@ -89,13 +90,7 @@ def _case_tail_unreachable(trans: HT.Translator | t.CPtr,
 # 委托函数用本地 _g_gen（cast 成 Generator 类型）调
 # StmtGenMixin 方法，避免函数体 import 包模块与类/模块名歧义。
 # ============================================================
-_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
+_g_gen: Generator.Generator | t.CPtr = None


@t.NoVTable
@@ -1334,7 +1329,6 @@ class MatchHandle(HandlesBase.Mixin):
 def NewMatchHandle(pool: memhub.MemBuddy | t.CPtr,
                   trans: HT.Translator | t.CPtr) -> MatchHandle | t.CPtr:
    """创建 MatchHandle 实例（委托到 gen.NewMatchHandle）"""
-    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.NewMatchHandle(pool, trans)
@@ -8,6 +8,7 @@ import stdio
 import lib.core.VLogger as VLogger
 import lib.core.Handles.HandlesTranslator as HT
 import lib.core.Handles.HandlesVar as HandlesVar
+import lib.core.Gen.Generator as Generator


 # ============================================================
@@ -45,13 +46,7 @@ import lib.core.Handles.HandlesVar as HandlesVar
 # 委托函数用本地 _g_gen（cast 成 Generator 类型）调
 # StmtGenMixin 方法，避免函数体 import 包模块与类/模块名歧义。
 # ============================================================
-_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
+_g_gen: Generator.Generator | t.CPtr = None


 # ============================================================
@@ -63,7 +58,6 @@ def set_global_gen(gen: t.CVoid | t.CPtr) -> None:
 # ============================================================
 def _is_void_type(ty: llvmlite.LLVMType | t.CPtr) -> int:
    """判断是否为 Void 类型，是则返回 1，否则 0（委托到 gen._is_void_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_void_type(ty)
@@ -75,7 +69,6 @@ def _is_void_type(ty: llvmlite.LLVMType | t.CPtr) -> int:
 # ============================================================
 def get_env_ptr_var(trans: HT.Translator | t.CPtr) -> llvmlite.Value | t.CPtr:
    """获取或创建 _env_ptr 变量（存储闭包 env 指针）（委托到 gen.get_env_ptr_var）"""
-    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_env_ptr_var(trans)
@@ -93,7 +86,6 @@ def _load_raw_var_ptr(trans: HT.Translator | t.CPtr,

    返回 i8* 类型的 Value，调用方需 bitcast 为具体类型指针后 load/store。
    """
-    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._load_raw_var_ptr(trans, name)
@@ -111,7 +103,6 @@ def load_nonlocal_var(trans: HT.Translator | t.CPtr,

    通过 HT.get_nonlocal_type 获取变量类型，bitcast 原始指针后 load。
    """
-    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.load_nonlocal_var(trans, name)
@@ -129,7 +120,6 @@ def get_nonlocal_var_ptr(trans: HT.Translator | t.CPtr,

    返回的指针指向父函数的 alloca，store 操作对父函数可见。
    """
-    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_nonlocal_var_ptr(trans, name)
@@ -9,7 +9,7 @@ import lib.core.Handles.HandlesTranslator as HT
 import lib.core.Handles.HandlesExpr as HandlesExpr
 import lib.core.Handles.HandlesVar as HandlesVar
 import lib.core.Handles.HandlesType as HandlesType
-
+import lib.core.Gen.Generator as Generator

 # ============================================================
 # HandlesReturn - Return 语句处理（P6 对象化后的委托层）
@@ -22,18 +22,8 @@ import lib.core.Handles.HandlesType as HandlesType

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


@t.NoVTable
@@ -231,7 +221,6 @@ class ReturnHandle(HandlesBase.Mixin):
 def NewReturnHandle(pool: memhub.MemBuddy | t.CPtr,
                    trans: HT.Translator | t.CPtr) -> ReturnHandle | t.CPtr:
    """创建 ReturnHandle 实例（委托到 gen.NewReturnHandle）"""
-    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.NewReturnHandle(pool, trans)
@@ -9,6 +9,7 @@ import ast
 import hashtable
 import viperlib
 import lib.core.VLogger as VLogger
+import lib.core.Gen.Generator as Generator


 # ============================================================
@@ -27,6 +28,11 @@ import lib.core.VLogger as VLogger
 # FieldEntry/StructEntry 类型与常量保留在本模块（gen 字段类型引用）。
 # ============================================================

+# ============================================================
+# 全局 gen 单例（模块级镜像，同 HandlesType 模式）
+# ============================================================
+_g_gen: Generator.Generator | t.CPtr = None
+
 STRUCT_MAX: t.CDefine = 512
 # 字段槽位上限制（Generator 43 Mixin 展平 ~120 字段；2026-08-16 追加78：64
 # 截断导致第 9+ 父类字段丢失 → __init__ 写 self.DiagStmtCount "属性写入失败"。
@@ -80,32 +86,8 @@ class StructEntry:
                           # → 链接 undefined symbol（list[ast.ClassDef|t.CPtr].* 根因）


-# ============================================================
-# 全局 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)
@@ -113,7 +95,6 @@ def set_stdlib_alloc(flag: int):

 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()
@@ -122,7 +103,6 @@ def get_stdlib_alloc() -> int:

 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)
@@ -130,7 +110,6 @@ def reset_visible_structs(pool: memhub.MemBuddy | t.CPtr, strict: int):

 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)
@@ -138,7 +117,6 @@ def add_visible_struct(pool: memhub.MemBuddy | t.CPtr, name: str):

 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)
@@ -147,7 +125,6 @@ def is_struct_visible(name: str) -> int:

 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)
@@ -156,7 +133,6 @@ def init_struct_table(pool: memhub.MemBuddy | t.CPtr) -> int:

 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)
@@ -165,7 +141,6 @@ def _get_struct_entry(i: int) -> StructEntry | t.CPtr:

 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)
@@ -177,7 +152,6 @@ def register_struct(pool: memhub.MemBuddy | t.CPtr,
                    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)
@@ -187,7 +161,6 @@ def register_struct(pool: memhub.MemBuddy | t.CPtr,
 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)
@@ -196,7 +169,6 @@ def set_struct_sha1(pool: memhub.MemBuddy | t.CPtr,

 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)
@@ -210,7 +182,6 @@ def add_field(pool: memhub.MemBuddy | 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,
@@ -220,7 +191,6 @@ def add_field(pool: memhub.MemBuddy | t.CPtr,

 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()
@@ -230,7 +200,6 @@ def get_struct_count() -> int:
 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)
@@ -239,7 +208,6 @@ def reset_module_methods_emitted(sha1: str) -> int:

 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)
@@ -248,7 +216,6 @@ def find_struct(name: str) -> StructEntry | t.CPtr:

 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)
@@ -257,7 +224,6 @@ def find_struct_by_module(name: str, sha1: str) -> StructEntry | t.CPtr:

 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)
@@ -267,7 +233,6 @@ def find_struct_by_type(struct_ty: llvmlite.LLVMType | t.CPtr) -> StructEntry |
 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)
@@ -278,7 +243,6 @@ 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)
@@ -287,7 +251,6 @@ def lookup_field_by_class(class_name: str,

 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)
@@ -297,7 +260,6 @@ def get_struct_type(class_name: str) -> llvmlite.LLVMType | t.CPtr:
 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)
@@ -306,7 +268,6 @@ def get_field_by_index(class_name: str,

 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)
@@ -315,7 +276,6 @@ def struct_has_defaults(class_name: str) -> int:

 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)
@@ -324,7 +284,6 @@ def get_struct_type_from_value(val: llvmlite.Value | t.CPtr) -> llvmlite.LLVMTyp

 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)
@@ -333,7 +292,6 @@ def mark_as_union(name: str) -> int:

 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)
@@ -342,7 +300,6 @@ def is_union_by_name(name: str) -> int:

 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)
@@ -351,7 +308,6 @@ def is_union_by_type(struct_ty: llvmlite.LLVMType | t.CPtr) -> int:

 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)
@@ -360,7 +316,6 @@ def mark_as_oop(name: str) -> int:

 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)
@@ -369,7 +324,6 @@ def is_oop_by_name(name: str) -> int:

 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)
@@ -378,7 +332,6 @@ def mark_has_init(name: str) -> int:

 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)
@@ -387,7 +340,6 @@ def has_init_by_name(name: str) -> int:

 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)
@@ -396,7 +348,6 @@ def mark_has_new(name: str) -> int:

 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)
@@ -406,7 +357,6 @@ def has_new_by_name(name: str) -> int:
 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)
@@ -415,7 +365,6 @@ def get_class_name_by_type(pool: memhub.MemBuddy | t.CPtr,

 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)
@@ -424,7 +373,6 @@ def _extract_struct_name(ty: llvmlite.LLVMType | t.CPtr) -> str:

 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)
@@ -433,7 +381,6 @@ def mark_has_vtable(name: str) -> int:

 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)
@@ -442,7 +389,6 @@ def has_vtable_by_name(name: str) -> int:

 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)
@@ -451,7 +397,6 @@ def mark_novtable(name: str) -> int:

 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)
@@ -460,7 +405,6 @@ def is_novtable_by_name(name: str) -> int:

 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)
@@ -471,7 +415,6 @@ 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)
@@ -480,7 +423,6 @@ def set_parent_names(pool: memhub.MemBuddy | t.CPtr,

 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)
@@ -489,7 +431,6 @@ def get_parent_count(name: str) -> int:

 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)
@@ -499,7 +440,6 @@ def get_parent_name_at(name: str, idx: int) -> str:
 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)
@@ -508,7 +448,6 @@ def get_mro_chain(pool: memhub.MemBuddy | t.CPtr,

 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)
@@ -517,7 +456,6 @@ def get_parent_name(name: str) -> str:

 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)
@@ -526,7 +464,6 @@ def set_vtable_methods(name: str, methods: str, count: int) -> int:

 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)
@@ -535,7 +472,6 @@ def get_vtable_method_index(name: str, method_name: str) -> int:

 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)
@@ -544,7 +480,6 @@ def get_vtable_method_count(name: str) -> int:

 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)
@@ -553,7 +488,6 @@ def get_vtable_method_name(name: str, idx: int) -> str:

 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)
@@ -564,7 +498,6 @@ 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)
@@ -574,7 +507,6 @@ 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)
@@ -582,7 +514,6 @@ def _ensure_field_types_in_module(pool: memhub.MemBuddy | t.CPtr,

 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)
@@ -591,7 +522,6 @@ def get_field_name_ptr(fe: FieldEntry | t.CPtr) -> str:

 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)
@@ -600,7 +530,6 @@ def get_field_type_ptr(fe: FieldEntry | t.CPtr) -> llvmlite.LLVMType | t.CPtr:

 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)
@@ -609,7 +538,6 @@ def get_field_default_ptr(fe: FieldEntry | t.CPtr) -> ast.AST | t.CPtr:

 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)
@@ -28,6 +28,9 @@ import lib.Projectrans.Config as Config
 import lib.core.StubMergerBuild as StubMergerBuild
 import lib.core.Handles.ExprCallHandle as ExprCallHandle
 import lib.core.Handles.ExprCallTable as ExprCallTable
+import lib.core.Handles.HandlesTranslator as HT
+import lib.core.Gen.Generator as Generator
+

 # ============================================================
 # HandlesTranslator - 翻译器状态管理 + 主入口
@@ -57,18 +60,8 @@ MAX_GLOBAL_NAMES: t.CDefine = 32

 # ============================================================
 # 全局 gen 单例（模块级镜像，同 HandlesType/HandlesStruct 模式）
-#
-# 由 BuildPipeline/main 在 gen 创建后调用 set_global_gen 注入。
-# P6-E 委托函数用本地 _g_gen（cast 成 Generator 类型）调
-# TranslatorGenMixin 方法，避免函数体 import 包模块与类/模块名歧义。
 # ============================================================
-_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
+_g_gen: Generator.Generator | t.CPtr = None


@t.NoVTable
@@ -599,7 +592,6 @@ class Translator:
 # ============================================================
 def add_global_name(trans: HT.Translator | t.CPtr, name: str):
    """添加一个 global 变量名（委托到 gen.add_global_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:
        g.add_global_name(trans, name)
@@ -607,7 +599,6 @@ def add_global_name(trans: HT.Translator | t.CPtr, name: str):

 def is_global_name(trans: HT.Translator | t.CPtr, name: str) -> int:
    """检查 name 是否在当前函数的 global 集合中（委托到 gen.is_global_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_global_name(trans, name)
@@ -623,7 +614,6 @@ def add_nonlocal_name(trans: HT.Translator | t.CPtr, name: str,
        var_ty: 变量的 LLVM 类型（用于 env 指针数组方案的类型恢复，
                None 时回退为 i32）
    """
-    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_nonlocal_name(trans, name, var_ty)
@@ -635,7 +625,6 @@ def get_nonlocal_type(trans: HT.Translator | t.CPtr,

    Returns: 找到的类型指针，找不到返回 None
    """
-    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_nonlocal_type(trans, name)
@@ -644,7 +633,6 @@ def get_nonlocal_type(trans: HT.Translator | t.CPtr,

 def is_nonlocal_name(trans: HT.Translator | t.CPtr, name: str) -> int:
    """检查 name 是否在当前函数的 nonlocal 集合中（委托到 gen.is_nonlocal_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_nonlocal_name(trans, name)
@@ -653,7 +641,6 @@ def is_nonlocal_name(trans: HT.Translator | t.CPtr, name: str) -> int:

 def get_nonlocal_index(trans: HT.Translator | t.CPtr, name: str) -> int:
    """获取 nonlocal 变量在 env 中的索引（0-based），找不到返回 -1（委托到 gen.get_nonlocal_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_nonlocal_index(trans, name)
@@ -662,7 +649,6 @@ def get_nonlocal_index(trans: HT.Translator | t.CPtr, name: str) -> int:

 def clear_scope_names(trans: HT.Translator | t.CPtr):
    """清空当前函数的 global/nonlocal 名称集合（进入新函数时调用）（委托到 gen.clear_scope_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:
        g.clear_scope_names(trans)
@@ -14,18 +14,11 @@ import lib.core.Handles.HandlesTranslator as HT
 import lib.core.Handles.HandlesImports as HandlesImports
 import lib.core.Handles.HandlesStruct as HandlesStruct
 import lib.core.Handles.HandlesVar as HandlesVar
+import lib.core.Gen.Generator as Generator


 # ============================================================
 # HandlesType - 类型映射与解析（P2 对象化后的委托层）
-#
-# str = bytes = t.CChar | t.CPtr = i8*
-#
-# P2 对象化重构（wiki/14-oo-refactor.md）：
-#   全部函数已迁移为 lib.core.Gen.TypeGenMixin 的方法（全局状态迁入
-#   gen 字段），本模块保留同名模块级函数作为"一行委托"：延迟 import
-#   Gen 取全局单例（BuildPipeline/main 创建后 set_global_gen 注册），
-#   再调用 gen 的对应方法。签名与旧函数完全一致，调用方零改动。
 # ============================================================


@@ -46,24 +39,8 @@ class TraceFrame:

 # ============================================================
 # 全局 gen 单例（模块级镜像）
-#
-# 由 BuildPipeline/main 在 gen 创建后调用 set_global_gen 注入。
-# 委托函数用本地 _g_gen（cast 成 Generator 类型），避免函数体
-# import 包模块（TPC 不注册包短名）与 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 未注册时正常流程不会发生；有返回值函数返回默认值）
 # ============================================================
+_g_gen: Generator.Generator | t.CPtr = None


 # ============================================================
@@ -81,7 +58,6 @@ CLASS_META_REQUIRE_MUST: t.CDefine = 3
 def register_class_meta(pool: memhub.MemBuddy | t.CPtr,
                        kind: int, cls: str, field: str) -> int:
    """注册类编译期元数据字段（委托到 gen.register_class_meta），0=成功"""
-    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_class_meta(pool, kind, cls, field)
@@ -90,7 +66,6 @@ def register_class_meta(pool: memhub.MemBuddy | t.CPtr,

 def class_meta_count(kind: int, cls: str) -> int:
    """返回某类某元数据类型的字段数（委托到 gen.class_meta_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.class_meta_count(kind, cls)
@@ -99,7 +74,6 @@ def class_meta_count(kind: int, cls: str) -> int:

 def class_meta_field_at(kind: int, cls: str, idx: int) -> str:
    """返回某类某元数据类型的第 idx 个字段名（委托到 gen.class_meta_field_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.class_meta_field_at(kind, cls, idx)
@@ -108,7 +82,6 @@ def class_meta_field_at(kind: int, cls: str, idx: int) -> str:

 def _ensure_trace_init() -> int:
    """确保调用栈已初始化（委托到 gen._ensure_trace_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._ensure_trace_init()
@@ -117,7 +90,6 @@ def _ensure_trace_init() -> int:

 def _get_trace_frame(i: int) -> TraceFrame | t.CPtr:
    """获取第 i 个 TraceFrame 槽位（委托到 gen._get_trace_frame）"""
-    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_trace_frame(i)
@@ -126,7 +98,6 @@ def _get_trace_frame(i: int) -> TraceFrame | t.CPtr:

 def push_trace(file_name: str, lineno: int, col_start: int = 0, col_end: int = 0):
    """压入一个翻译上下文帧（委托到 gen.push_trace）"""
-    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.push_trace(file_name, lineno, col_start, col_end)
@@ -134,7 +105,6 @@ def push_trace(file_name: str, lineno: int, col_start: int = 0, col_end: int = 0

 def pop_trace():
    """弹出栈顶帧（委托到 gen.pop_trace）"""
-    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.pop_trace()
@@ -142,7 +112,6 @@ def pop_trace():

 def clear_trace():
    """清空调用栈（委托到 gen.clear_trace）"""
-    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.clear_trace()
@@ -150,7 +119,6 @@ def clear_trace():

 def set_temp_dir(temp_dir: str) -> None:
    """设置全局 temp_dir（委托到 gen.set_temp_dir）"""
-    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_temp_dir(temp_dir)
@@ -158,7 +126,6 @@ def set_temp_dir(temp_dir: str) -> None:

 def get_temp_dir() -> str:
    """获取全局 temp_dir（委托到 gen.get_temp_dir）"""
-    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_temp_dir()
@@ -167,7 +134,6 @@ def get_temp_dir() -> str:

 def set_current_module_sha1(sha1: str) -> None:
    """设置当前正在编译的模块 SHA1（委托到 gen.set_current_module_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:
        g.set_current_module_sha1(sha1)
@@ -182,7 +148,6 @@ def _dbg_check_ast_floats(mb: memhub.MemBuddy | t.CPtr,
 def register_cdefine_constant(pool: memhub.MemBuddy | t.CPtr,
                              name: str, value: t.CInt64T) -> None:
    """注册 CDefine 编译期常量到本地表（委托到 gen.register_cdefine_constant）"""
-    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.register_cdefine_constant(pool, name, value)
@@ -191,7 +156,6 @@ def register_cdefine_constant(pool: memhub.MemBuddy | t.CPtr,
 def register_cdefine_double(pool: memhub.MemBuddy | t.CPtr,
                            name: str, value: double) -> None:
    """注册浮点 CDefine 编译期常量（委托到 gen.register_cdefine_double）"""
-    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.register_cdefine_double(pool, name, value)
@@ -200,7 +164,6 @@ def register_cdefine_double(pool: memhub.MemBuddy | t.CPtr,
 def register_cdefine_string(pool: memhub.MemBuddy | t.CPtr,
                            name: str, value: str) -> None:
    """注册字符串 CDefine 编译期常量（委托到 gen.register_cdefine_string）"""
-    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.register_cdefine_string(pool, name, value)
@@ -208,7 +171,6 @@ def register_cdefine_string(pool: memhub.MemBuddy | t.CPtr,

 def lookup_cdefine_constant(name: str) -> t.CInt64T:
    """查找 CDefine 编译期常量（委托到 gen.lookup_cdefine_constant）"""
-    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_cdefine_constant(name)
@@ -217,7 +179,6 @@ def lookup_cdefine_constant(name: str) -> t.CInt64T:

 def lookup_cdefine_double(name: str) -> double:
    """查找 CDefine 编译期常量，返回 double 值（委托到 gen.lookup_cdefine_double）"""
-    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_cdefine_double(name)
@@ -226,7 +187,6 @@ def lookup_cdefine_double(name: str) -> double:

 def lookup_cdefine_string(name: str) -> str:
    """查找 CDefine 编译期字符串值（委托到 gen.lookup_cdefine_string）"""
-    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_cdefine_string(name)
@@ -235,7 +195,6 @@ def lookup_cdefine_string(name: str) -> str:

 def is_cdefine_str() -> int:
    """检查最近一次 CDefine 查找命中的是否是字符串常量（委托到 gen.is_cdefine_str）"""
-    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_cdefine_str()
@@ -248,7 +207,6 @@ def eval_ctraits_isptr(symtab: HandlesVar.SymbolTable | t.CPtr,

    返回: 1=指针 0=非指针 -1=无法求值。
    """
-    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._eval_ctraits_isptr(symtab, name)
@@ -257,7 +215,6 @@ def eval_ctraits_isptr(symtab: HandlesVar.SymbolTable | t.CPtr,

 def is_cdefine_double() -> int:
    """检查最近一次 CDefine 查找命中的是否是浮点常量（委托到 gen.is_cdefine_double）"""
-    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_cdefine_double()
@@ -266,7 +223,6 @@ def is_cdefine_double() -> int:

 def is_cdefine_found() -> int:
    """检查上次 lookup_cdefine_constant 是否找到值（委托到 gen.is_cdefine_found）"""
-    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_cdefine_found()
@@ -275,7 +231,6 @@ def is_cdefine_found() -> int:

 def set_cdefine_found(val: int) -> None:
    """设置 cdefine_found 标志（委托到 gen.set_cdefine_found）"""
-    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_cdefine_found(val)
@@ -283,7 +238,6 @@ def set_cdefine_found(val: int) -> None:

 def clear_cdefine_constants() -> None:
    """清空 CDefine 常量表（委托到 gen.clear_cdefine_constants）"""
-    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.clear_cdefine_constants()
@@ -292,7 +246,6 @@ def clear_cdefine_constants() -> None:
 def register_xmod_cdefine(name: str, value_str: str,
                          is_double: int, is_str: int) -> None:
    """注册跨模块 CDefine 查找结果到 perm_pool 全局缓存（委托到 gen.register_xmod_cdefine）"""
-    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.register_xmod_cdefine(name, value_str, is_double, is_str)
@@ -300,7 +253,6 @@ def register_xmod_cdefine(name: str, value_str: str,

 def lookup_xmod_cdefine(name: str) -> str:
    """查找跨模块 CDefine 缓存（委托到 gen.lookup_xmod_cdefine）"""
-    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_xmod_cdefine(name)
@@ -310,7 +262,6 @@ def lookup_xmod_cdefine(name: str) -> str:
 def register_ctypedef(pool: memhub.MemBuddy | t.CPtr,
                      name: str, type_str: str) -> None:
    """注册 CTypedef 到本地表（委托到 gen.register_ctypedef）"""
-    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.register_ctypedef(pool, name, type_str)
@@ -318,7 +269,6 @@ def register_ctypedef(pool: memhub.MemBuddy | t.CPtr,

 def lookup_ctypedef(name: str) -> str:
    """查找 CTypedef，返回类型表达式字符串（委托到 gen.lookup_ctypedef）"""
-    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_ctypedef(name)
@@ -327,7 +277,6 @@ def lookup_ctypedef(name: str) -> str:

 def is_ctypedef_found() -> int:
    """检查上次 lookup_ctypedef 是否找到值（委托到 gen.is_ctypedef_found）"""
-    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_ctypedef_found()
@@ -336,7 +285,6 @@ def is_ctypedef_found() -> int:

 def clear_ctypedefs() -> None:
    """清空 CTypedef 表（委托到 gen.clear_ctypedefs）"""
-    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.clear_ctypedefs()
@@ -344,7 +292,6 @@ def clear_ctypedefs() -> None:

 def _ctypedef_push_visiting(pool: memhub.MemBuddy | t.CPtr, name: str) -> int:
    """将 CTypedef 名加入正在解析列表（委托到 gen._ctypedef_push_visiting）"""
-    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._ctypedef_push_visiting(pool, name)
@@ -353,7 +300,6 @@ def _ctypedef_push_visiting(pool: memhub.MemBuddy | t.CPtr, name: str) -> int:

 def _ctypedef_pop_visiting() -> None:
    """从正在解析列表弹出最后一个 CTypedef 名（委托到 gen._ctypedef_pop_visiting）"""
-    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._ctypedef_pop_visiting()
@@ -361,7 +307,6 @@ def _ctypedef_pop_visiting() -> None:

 def _is_ctypedef_annotation(annotation: ast.AST | t.CPtr) -> int:
    """检测类型注解是否为 t.CTypedef（委托到 gen._is_ctypedef_annotation）"""
-    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_ctypedef_annotation(annotation)
@@ -371,7 +316,6 @@ def _is_ctypedef_annotation(annotation: ast.AST | t.CPtr) -> int:
 def ScanCTypedefDeclarations(pool: memhub.MemBuddy | t.CPtr,
                             tree: ast.AST | t.CPtr) -> int:
    """扫描 AST 顶层节点，注册所有 NAME: t.CTypedef = Type 声明（委托到 gen.ScanCTypedefDeclarations）"""
-    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.ScanCTypedefDeclarations(pool, tree)
@@ -386,7 +330,6 @@ def RegisterCTypedefFromSource(pool: memhub.MemBuddy | t.CPtr,
    src_buf，跨阶段内容不稳定（悬空），ScanCTypedefDeclarations 读 attr
    会 0xC0000005。改用文本匹配 "NAME: t.CTypedef = 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.register_ctypedef_from_source(pool, src)
@@ -398,7 +341,6 @@ def _eval_const_int_expr(node: ast.AST | t.CPtr,
                         from_imports: str = None,
                         imported_modules: str = None) -> int:
    """递归计算常量整数表达式（委托到 gen._eval_const_int_expr）"""
-    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._eval_const_int_expr(node, pool, from_imports, imported_modules)
@@ -408,7 +350,6 @@ def _eval_const_int_expr(node: ast.AST | t.CPtr,
 def set_generic_context(tp_names: list[str] | t.CPtr,
                        type_args: list[str] | t.CPtr):
    """设置泛型特化上下文（委托到 gen.set_generic_context）"""
-    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_generic_context(tp_names, type_args)
@@ -416,7 +357,6 @@ def set_generic_context(tp_names: list[str] | t.CPtr,

 def clear_generic_context():
    """清除泛型特化上下文（委托到 gen.clear_generic_context）"""
-    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.clear_generic_context()
@@ -424,7 +364,6 @@ def clear_generic_context():

 def resolve_generic_type_name(name: str) -> str:
    """如果 name 是泛型类型参数，返回对应的具体类型名（委托到 gen.resolve_generic_type_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.resolve_generic_type_name(name)
@@ -434,7 +373,6 @@ def resolve_generic_type_name(name: str) -> str:
 def _get_type_name_from_annotation(pool: memhub.MemBuddy | t.CPtr,
                                   node: ast.AST | t.CPtr) -> str:
    """从类型注解节点提取类型名（委托到 gen._get_type_name_from_annotation）"""
-    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_type_name_from_annotation(pool, node)
@@ -445,7 +383,6 @@ def _parse_type_string(pool: memhub.MemBuddy | t.CPtr,
                       type_str: str,
                       ctx: t.CInt) -> ast.AST | t.CPtr:
    """将类型名字符串解析为 AST 节点（委托到 gen._parse_type_string）"""
-    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._parse_type_string(pool, type_str, ctx)
@@ -454,7 +391,6 @@ def _parse_type_string(pool: memhub.MemBuddy | t.CPtr,

 def set_current_file(file_path: str):
    """设置当前编译的文件名（委托到 gen.set_current_file）"""
-    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_current_file(file_path)
@@ -462,7 +398,6 @@ def set_current_file(file_path: str):

 def get_current_file() -> str:
    """获取当前编译的文件名（委托到 gen.get_current_file）"""
-    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_current_file()
@@ -471,7 +406,6 @@ def get_current_file() -> str:

 def _read_source_line(file_path: str, lineno: int) -> str:
    """从源文件读取第 lineno 行内容（委托到 gen._read_source_line）"""
-    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._read_source_line(file_path, lineno)
@@ -480,7 +414,6 @@ def _read_source_line(file_path: str, lineno: int) -> str:

 def read_source_line(file_path: str, lineno: int) -> str:
    """公开包装：从源文件读取第 lineno 行内容（委托到 gen.read_source_line）"""
-    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.read_source_line(file_path, lineno)
@@ -489,7 +422,6 @@ def read_source_line(file_path: str, lineno: int) -> str:

 def dump_parse_traceback(file_path: str):
    """解析失败时以 Python 风格输出 traceback（委托到 gen.dump_parse_traceback）"""
-    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.dump_parse_traceback(file_path)
@@ -499,7 +431,6 @@ def fatal_error(node: ast.AST | t.CPtr, msg: str,
                err_type: str = "SyntaxError",
                col_start: int = 0, col_end: int = 0):
    """以 Python 风格报错并退出（委托到 gen.fatal_error）"""
-    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.fatal_error(node, msg, err_type, col_start, col_end)
@@ -508,7 +439,6 @@ def fatal_error(node: ast.AST | t.CPtr, msg: str,
 def fatal_type_error(node: ast.AST | t.CPtr, msg: str,
                     col_start: int = 0, col_end: int = 0):
    """以 Python 风格报错并退出（TypeError 版本，委托到 gen.fatal_type_error）"""
-    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.fatal_type_error(node, msg, col_start, col_end)
@@ -520,7 +450,6 @@ def try_extract_callable_ret(pool: memhub.MemBuddy | t.CPtr,
                             from_imports: str,
                             trans: HT.Translator | t.CPtr) -> llvmlite.LLVMType | t.CPtr:
    """提取 t.Callable 注解的返回类型 LLVMType（委托到 gen.try_extract_callable_ret）"""
-    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.try_extract_callable_ret(pool, annot, imported_modules, from_imports, trans)
@@ -530,7 +459,6 @@ def try_extract_callable_ret(pool: memhub.MemBuddy | t.CPtr,
 def map_t_type(pool: memhub.MemBuddy | t.CPtr,
               type_name: str) -> llvmlite.LLVMType | t.CPtr:
    """将 t.CXxx / c.CXxx 类型名映射到 LLVMType（委托到 gen.map_t_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.map_t_type(pool, type_name)
@@ -541,7 +469,6 @@ def _is_t_attr(node: ast.AST | t.CPtr,
               attr_name: str,
               imported_modules: str) -> int:
    """检测节点是否是 t.attr_name 形式（委托到 gen._is_t_attr）"""
-    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_t_attr(node, attr_name, imported_modules)
@@ -551,7 +478,6 @@ def _is_t_attr(node: ast.AST | t.CPtr,
 def _is_cptr_marker(node: ast.AST | t.CPtr,
                    imported_modules: str) -> int:
    """检测节点是否为 CPtr 指针标记（委托到 gen._is_cptr_marker）"""
-    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_cptr_marker(node, imported_modules)
@@ -561,7 +487,6 @@ def _is_cptr_marker(node: ast.AST | t.CPtr,
 def _is_cvoid_marker(node: ast.AST | t.CPtr,
                     imported_modules: str) -> int:
    """检测节点是否为 CVoid 指针标记（委托到 gen._is_cvoid_marker）"""
-    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_cvoid_marker(node, imported_modules)
@@ -570,7 +495,6 @@ def _is_cvoid_marker(node: ast.AST | t.CPtr,

 def annotation_to_str(annot: ast.AST | t.CPtr) -> str:
    """将类型注解 AST 转换为可读字符串（委托到 gen.annotation_to_str）"""
-    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.annotation_to_str(annot)
@@ -581,7 +505,6 @@ def extract_class_name_from_annotation(node: ast.AST | t.CPtr,
                                       imported_modules: str,
                                       pool: memhub.MemBuddy | t.CPtr = None) -> str:
    """从类型注解 AST 中提取类名（委托到 gen.extract_class_name_from_annotation）"""
-    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_class_name_from_annotation(node, imported_modules, pool)
@@ -595,7 +518,6 @@ def _resolve_generic_subscript_ty(pool: memhub.MemBuddy | t.CPtr,
                                  imported_modules: str,
                                  from_imports: str) -> llvmlite.LLVMType | t.CPtr:
    """解析泛型类类型注解（委托到 gen._resolve_generic_subscript_ty）"""
-    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._resolve_generic_subscript_ty(pool, sub, gen_cls_name, trans,
@@ -609,7 +531,6 @@ def resolve_annotation_type(pool: memhub.MemBuddy | t.CPtr,
                            from_imports: str,
                            trans: HT.Translator | t.CPtr = None) -> llvmlite.LLVMType | t.CPtr:
    """解析类型注解节点为 LLVMType（委托到 gen.resolve_annotation_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.resolve_annotation_type(pool, node, imported_modules, from_imports, trans)
@@ -619,7 +540,6 @@ def resolve_annotation_type(pool: memhub.MemBuddy | t.CPtr,
 def has_decorator_marker(node: ast.AST | t.CPtr,
                         marker_name: str) -> int:
    """检测类型注解中是否包含指定的装饰器标记（委托到 gen.has_decorator_marker）"""
-    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_decorator_marker(node, marker_name)
@@ -628,7 +548,6 @@ def has_decorator_marker(node: ast.AST | t.CPtr,

 def is_pass_body(body: list[ast.AST | t.CPtr] | t.CPtr) -> int:
    """检测函数体是否为 pass（委托到 gen.is_pass_body）"""
-    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_pass_body(body)
@@ -637,7 +556,6 @@ def is_pass_body(body: list[ast.AST | t.CPtr] | t.CPtr) -> int:

 def get_llvm_type_bits(ty: llvmlite.LLVMType | t.CPtr) -> int:
    """获取 LLVM 整数类型的位宽（委托到 gen.get_llvm_type_bits）"""
-    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_llvm_type_bits(ty)
@@ -648,7 +566,6 @@ def infer_expr_type(pool: memhub.MemBuddy | t.CPtr,
                    node: ast.AST | t.CPtr,
                    param_types: str) -> llvmlite.LLVMType | t.CPtr:
    """推断表达式的 LLVM 类型（委托到 gen.infer_expr_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.infer_expr_type(pool, node, param_types)
@@ -659,7 +576,6 @@ def infer_return_type(pool: memhub.MemBuddy | t.CPtr,
                      body: list[ast.AST | t.CPtr] | t.CPtr,
                      param_types: str) -> llvmlite.LLVMType | t.CPtr:
    """扫描函数体中的 return 语句，推断返回类型（委托到 gen.infer_return_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.infer_return_type(pool, body, param_types)
@@ -669,7 +585,6 @@ def infer_return_type(pool: memhub.MemBuddy | t.CPtr,
 def build_param_types_str(pool: memhub.MemBuddy | t.CPtr,
                          args_node: ast.AST | t.CPtr) -> str:
    """构建参数类型编码字符串（委托到 gen.build_param_types_str）"""
-    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.build_param_types_str(pool, args_node)
@@ -678,7 +593,6 @@ def build_param_types_str(pool: memhub.MemBuddy | t.CPtr,

 def _strappend(dst: str, dst_size: t.CSizeT, src: str):
    """将 src 追加到 dst 末尾（委托到 gen._strappend）"""
-    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._strappend(dst, dst_size, src)
@@ -3,6 +3,7 @@ from stdint import *
 import llvmlite
 import memhub
 import string
+import lib.core.Gen.Generator as Generator


 # ============================================================
@@ -86,13 +87,7 @@ class SymbolTable:
 # VarGenMixin 方法，避免函数体 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
+_g_gen: Generator.Generator | t.CPtr = None


 # ============================================================
@@ -106,7 +101,6 @@ def set_global_gen(gen: t.CVoid | t.CPtr) -> None:
 # ============================================================
 def init_vars(pool: memhub.MemBuddy | t.CPtr) -> VarEntry | t.CPtr:
    """分配并清零变量表数组（委托到 gen.init_vars）"""
-    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_vars(pool)
@@ -120,7 +114,6 @@ def find_var(vars_ptr: VarEntry | t.CPtr,
             var_count: int,
             name: str) -> llvmlite.Value | t.CPtr:
    """在变量表中按名称查找（委托到 gen.find_var）"""
-    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_var(vars_ptr, var_count, name)
@@ -134,7 +127,6 @@ def find_var_entry(vars_ptr: VarEntry | t.CPtr,
                   var_count: int,
                   name: str) -> VarEntry | t.CPtr:
    """在变量表中按名称查找，返回 VarEntry 或 None（委托到 gen.find_var_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.find_var_entry(vars_ptr, var_count, name)
@@ -147,7 +139,6 @@ def find_var_entry(vars_ptr: VarEntry | t.CPtr,
 def lookup_var_entry(symtab: SymbolTable | t.CPtr,
                     name: str) -> VarEntry | t.CPtr:
    """从当前作用域逐级向上查找变量，返回 VarEntry 或 None（委托到 gen.lookup_var_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.lookup_var_entry(symtab, name)
@@ -165,7 +156,6 @@ def set_var_annot_class_name(symtab: SymbolTable | t.CPtr,
                             name: str,
                             class_name: str) -> int:
    """设置变量的原始类型注解类名，返回 0=成功 / 1=失败（委托到 gen.set_var_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.set_var_annot_class_name(symtab, name, class_name)
@@ -182,7 +172,6 @@ def set_var_annot_class_name(symtab: SymbolTable | t.CPtr,
 def set_var_ptr_element(symtab: SymbolTable | t.CPtr,
                        name: str) -> int:
    """标记变量为 ptr_element 类型，返回 0=成功 / 1=失败（委托到 gen.set_var_ptr_element）"""
-    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_var_ptr_element(symtab, name)
@@ -197,7 +186,6 @@ def add_var(vars_ptr: VarEntry | t.CPtr,
            name: str,
            alloca: llvmlite.Value | t.CPtr) -> int:
    """添加变量到变量表（委托到 gen.add_var）"""
-    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_var(vars_ptr, var_count, name, alloca)
@@ -220,7 +208,6 @@ def _alloca_at_entry(builder: llvmlite.IRBuilder | t.CPtr,
    使用 llvmlite.build_alloca_at_entry 在入口块终止指令之前插入 alloca，
    确保所有 alloca 在入口块，避免支配性违规。
    """
-    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._alloca_at_entry(builder, ty)
@@ -237,7 +224,6 @@ def get_or_create_var(pool: memhub.MemBuddy | t.CPtr,
                      name: str,
                      ty: llvmlite.LLVMType | t.CPtr) -> llvmlite.Value | t.CPtr:
    """查找或创建变量 alloca（委托到 gen.get_or_create_var）"""
-    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_or_create_var(pool, builder, vars_ptr, var_count, name, ty)
@@ -251,7 +237,6 @@ def _create_scope(pool: memhub.MemBuddy | t.CPtr,
                  parent: Scope | t.CPtr,
                  kind: int) -> Scope | t.CPtr:
    """创建并初始化作用域节点（委托到 gen._create_scope）"""
-    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._create_scope(pool, parent, kind)
@@ -263,7 +248,6 @@ def _create_scope(pool: memhub.MemBuddy | t.CPtr,
 # ============================================================
 def init_symbol_table(pool: memhub.MemBuddy | t.CPtr) -> SymbolTable | t.CPtr:
    """创建并初始化符号表，包含模块级根作用域（委托到 gen.init_symbol_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_symbol_table(pool)
@@ -276,7 +260,6 @@ def init_symbol_table(pool: memhub.MemBuddy | t.CPtr) -> SymbolTable | t.CPtr:
 def enter_scope(symtab: SymbolTable | t.CPtr,
                kind: int) -> Scope | t.CPtr:
    """进入新作用域，返回新创建的作用域（委托到 gen.enter_scope）"""
-    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.enter_scope(symtab, kind)
@@ -288,7 +271,6 @@ def enter_scope(symtab: SymbolTable | t.CPtr,
 # ============================================================
 def exit_scope(symtab: SymbolTable | t.CPtr):
    """退出当前作用域，恢复到父作用域（委托到 gen.exit_scope）"""
-    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.exit_scope(symtab)
@@ -301,7 +283,6 @@ def define_var(symtab: SymbolTable | t.CPtr,
               name: str,
               alloca: llvmlite.Value | t.CPtr) -> int:
    """在当前作用域定义变量，返回 0 成功（委托到 gen.define_var）"""
-    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.define_var(symtab, name, alloca)
@@ -315,7 +296,6 @@ def define_module_var(symtab: SymbolTable | t.CPtr,
                      name: str,
                      alloca: llvmlite.Value | t.CPtr) -> int:
    """在模块作用域定义变量，返回 0 成功（委托到 gen.define_module_var）"""
-    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.define_module_var(symtab, name, alloca)
@@ -328,7 +308,6 @@ def define_module_var(symtab: SymbolTable | t.CPtr,
 def lookup_var(symtab: SymbolTable | t.CPtr,
               name: str) -> llvmlite.Value | t.CPtr:
    """从当前作用域逐级向上查找变量，返回 alloca 或 None（委托到 gen.lookup_var）"""
-    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_var(symtab, name)
@@ -341,7 +320,6 @@ def lookup_var(symtab: SymbolTable | t.CPtr,
 def lookup_current(symtab: SymbolTable | t.CPtr,
                   name: str) -> llvmlite.Value | t.CPtr:
    """仅在当前作用域查找变量（委托到 gen.lookup_current）"""
-    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_current(symtab, name)
@@ -354,7 +332,6 @@ def lookup_current(symtab: SymbolTable | t.CPtr,
 def lookup_module_var(symtab: SymbolTable | t.CPtr,
                      name: str) -> llvmlite.Value | t.CPtr:
    """在模块作用域查找变量（委托到 gen.lookup_module_var）"""
-    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_module_var(symtab, name)
@@ -373,7 +350,6 @@ def is_module_scope(symtab: SymbolTable | t.CPtr) -> int:

    Returns: 1=模块级作用域, 0=函数内作用域
    """
-    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_module_scope(symtab)
@@ -389,7 +365,6 @@ def get_or_create_sym(symtab: SymbolTable | t.CPtr,
                      name: str,
                      ty: llvmlite.LLVMType | t.CPtr) -> llvmlite.Value | t.CPtr:
    """查找或创建变量 alloca（在当前作用域，委托到 gen.get_or_create_sym）"""
-    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_or_create_sym(symtab, pool, builder, name, ty)
@@ -11,6 +11,7 @@ import lib.core.Handles.HandlesTranslator as HT
 import lib.core.Handles.HandlesExpr as HandlesExpr
 import lib.core.Handles.HandlesBody as HandlesBody
 import lib.core.Handles.HandlesType as HandlesType
+import lib.core.Gen.Generator as Generator


 # ============================================================
@@ -40,13 +41,7 @@ import lib.core.Handles.HandlesType as HandlesType
 # 委托函数用本地 _g_gen（cast 成 Generator 类型）调
 # StmtGenMixin 方法，避免函数体 import 包模块与类/模块名歧义。
 # ============================================================
-_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
+_g_gen: Generator.Generator | t.CPtr = None


@t.NoVTable
@@ -159,7 +154,6 @@ class WhileHandle(HandlesBase.Mixin):
 def NewWhileHandle(pool: memhub.MemBuddy | t.CPtr,
                   trans: HT.Translator | t.CPtr) -> WhileHandle | t.CPtr:
    """创建 WhileHandle 实例（委托到 gen.NewWhileHandle）"""
-    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.NewWhileHandle(pool, trans)
@@ -68,6 +68,8 @@ V_TERMINEXUS_AGE: t.CDefine = "15.3"
 V_TPC_COMMIT: t.CDefine = "a641c7c8da/2026‑08‑17T02:49:00Z"
 V_TPV_COMMIT: t.CDefine = ""
 V_RUNTIME_COMMIT: t.CDefine = "14ff9d109f/2026-08-17T03:02:20Z"
+V_TARGET: t.CDefine = "x86_64-w64-windows-gnu"
+V_LLVM: t.CDefine = "22.1.8"

 # ============================================================
 # main: Command-line entry
@@ -102,20 +104,20 @@ def main() -> int:
    # 设置全局 mbuddy 指针（sys 和 argparse 都需要）
    sys._mbuddy = mb
    argparse._mbuddy = mb
-    ast._mbuddy = (memhub.MemBuddy | t.CPtr)(mb)
-    lib._mbuddy = (memhub.MemBuddy | t.CPtr)(mb)
-    Config._mbuddy = (memhub.MemBuddy | t.CPtr)(mb)
-    Utils._mbuddy = (memhub.MemBuddy | t.CPtr)(mb)
+    ast._mbuddy = mb
+    lib._mbuddy = mb
+    Config._mbuddy = mb
+    Utils._mbuddy = mb
    HandlesTranslator._mbuddy = mb
-    BuildPipeline._mbuddy = (memhub.MemBuddy | t.CPtr)(mb)
-    IncludesScanner._mbuddy = (memhub.MemBuddy | t.CPtr)(mb)
-    StubMerger._mbuddy = (memhub.MemBuddy | t.CPtr)(mb)
-    Phase1._mbuddy = (memhub.MemBuddy | t.CPtr)(mb)
-    Phase2._mbuddy = (memhub.MemBuddy | t.CPtr)(mb)
+    BuildPipeline._mbuddy = mb
+    IncludesScanner._mbuddy = mb
+    StubMerger._mbuddy = mb
+    Phase1._mbuddy = mb
+    Phase2._mbuddy = mb
    subprocess._mbuddy = mb
-    # hashlib._mbuddy = (memhub.MemBuddy | t.CPtr)(mb)
-    VLogger._mbuddy = (memhub.MemBuddy | t.CPtr)(mb)
-    lib.InitLib((memhub.MemBuddy | t.CPtr)(mb))
+    # hashlib._mbuddy = (mb)
+    VLogger._mbuddy = mb
+    lib.InitLib(mb)

    # P2: 创建项目级 Generator 单例（Phase1/Phase2/BuildPipeline 全程复用；
    # HandlesType 等旧模块函数经延迟 import 委托到 gen 方法，实现对象化过渡）
@@ -126,30 +128,30 @@ def main() -> int:
    gen.__before_init__()
    gen.__init__(mb)

-    GenGenerator.set_global_gen(gen)
+    GenGenerator._g_gen = gen
    # P2-P5: 注入各 Handles 模块级单例（Phase1 阶段即调用其状态函数）
-    HandlesType.set_global_gen(gen)
-    HandlesStruct.set_global_gen(gen)
-    HandlesExpr.set_global_gen(gen)
-    HandlesExprOps.set_global_gen(gen)
-    HandlesExprCall.set_global_gen(gen)
-    HandlesFunctions.set_global_gen(gen)
-    HandlesClassDef.set_global_gen(gen)
+    HandlesType._g_gen = gen
+    HandlesStruct._g_gen = gen
+    HandlesExpr._g_gen = gen
+    HandlesExprOps._g_gen = gen
+    HandlesExprCall._g_gen = gen
+    HandlesFunctions._g_gen = gen
+    HandlesClassDef._g_gen = gen
    # P6: 注入语句/赋值/变量/导入/翻译驱动模块的单例
-    HandlesImports.set_global_gen(gen)
-    HandlesBody.set_global_gen(gen)
-    HandlesIf.set_global_gen(gen)
-    HandlesWhile.set_global_gen(gen)
-    HandlesFor.set_global_gen(gen)
-    HandlesReturn.set_global_gen(gen)
-    HandlesNonlocal.set_global_gen(gen)
-    HandlesMatch.set_global_gen(gen)
-    HandlesEnum.set_global_gen(gen)
-    HandlesAnnAssign.set_global_gen(gen)
-    HandlesAugAssign.set_global_gen(gen)
-    HandlesVar.set_global_gen(gen)
-    HandlesTranslator.set_global_gen(gen)
-    HandlesMain.set_global_gen(gen)
+    HandlesImports._g_gen = gen
+    HandlesBody._g_gen = gen
+    HandlesIf._g_gen = gen
+    HandlesWhile._g_gen = gen
+    HandlesFor._g_gen = gen
+    HandlesReturn._g_gen = gen
+    HandlesNonlocal._g_gen = gen
+    HandlesMatch._g_gen = gen
+    HandlesEnum._g_gen = gen
+    HandlesAnnAssign._g_gen = gen
+    HandlesAugAssign._g_gen = gen
+    HandlesVar._g_gen = gen
+    HandlesTranslator._g_gen = gen
+    HandlesMain._g_gen = gen

    # 初始化 VLogger 并打印启动日志
    log: VLogger.Logger | t.CPtr = VLogger.get_logger()
@@ -272,9 +274,6 @@ Target: %s
        Config.set_inc_bin_suffix(".binary")

    # --nowarn-register：抑制"外部函数返回类型未登记"类 WARN 输出
-    # （自举编译中大量出现刷屏，仅抑制打印，默认 i32 推断/标记重试逻辑保留）
-    # 注意：argparse 的 dest 保留短横线（"--nowarn-register" → "nowarn-register"），
-    # 读取时必须用破折号 key，否则 get_bool 查不到 → 开关永不置位 → WARN 照打。
    if args.get_bool("nowarn-register"):
        VLogger.set_nowarn_register(1)
        if log is not None: