自举实验失败，C1 编译 Test 成功，暂未达到自举收敛点

App/lib/core/Handles/HandlesAnnAssign.py

@@ -176,6 +176,77 @@ def _is_ptr_element_annotation(annot: ast.AST | t.CPtr) -> int:
     return 0
 
 
+# ============================================================
+# _init_global_array_from_list — 从列表字面量初始化全局数组
+#
+# 为每个元素生成 GEP + store 指令，将值存入全局数组的对应位置。
+# 适用于模块级 t.CArray[elem_ty, count] = [v0, v1, ...] 的初始化。
+#
+# Args:
+#   builder: IRBuilder
+#   pool: 编译器内存池
+#   mod: LLVMModule
+#   array_alloca: 全局数组变量的 Value 引用（类型为 [N x elem_ty]*）
+#   list_node: ast.List 节点
+#   trans: Translator 对象
+#
+# Returns:
+#   0 成功，1 失败
+# ============================================================
+def _init_global_array_from_list(builder: llvmlite.IRBuilder | t.CPtr,
+                                 pool: memhub.MemBuddy | t.CPtr,
+                                 mod: llvmlite.LLVMModule | t.CPtr,
+                                 array_alloca: llvmlite.Value | t.CPtr,
+                                 list_node: ast.AST | t.CPtr,
+                                 trans: HT.Translator | t.CPtr) -> int:
+    """从列表字面量初始化全局数组，为每个元素生成 GEP + store"""
+    if builder is None or array_alloca is None or list_node is None:
+        return 1
+
+    # 获取数组类型（Pointee of [N x elem_ty]*）
+    arr_ty: llvmlite.LLVMType | t.CPtr = None
+    if array_alloca.Ty is not None:
+        arr_ty = array_alloca.Ty.Pointee
+    if arr_ty is None:
+        return 1
+
+    # 匹配数组类型获取元素类型
+    elem_ty: llvmlite.LLVMType | t.CPtr = None
+    match arr_ty:
+        case llvmlite.LLVMType.Array(et, _):
+            elem_ty = et
+    if elem_ty is None:
+        return 1
+
+    # 获取列表元素
+    lst: ast.List | t.CPtr = (ast.List | t.CPtr)(list_node)
+    if lst is None or lst.elts is None:
+        return 1
+    elts: list[ast.AST | t.CPtr] | t.CPtr = lst.elts
+    elts_count: t.CSizeT = elts.__len__()
+
+    # 为每个元素生成 GEP + store
+    i: t.CSizeT = 0
+    while i < elts_count:
+        elem_node: ast.AST | t.CPtr = elts.get(i)
+        elem_val: llvmlite.Value | t.CPtr = HandlesExpr.translate_value(
+            builder, pool, mod, elem_node, None, 0, trans)
+        if elem_val is not None:
+            idx_val: llvmlite.Value | t.CPtr = llvmlite.const_int32(pool, i)
+            elem_ptr: llvmlite.Value | t.CPtr = llvmlite.build_gep_array(
+                builder, arr_ty, elem_ty, array_alloca, idx_val)
+            if elem_ptr is not None:
+                # 类型转换（如 i32 → i8 截断）
+                store_val: llvmlite.Value | t.CPtr = elem_val
+                if elem_ptr.Ty is not None and elem_ptr.Ty.Pointee is not None:
+                    store_val = HandlesExpr.coerce_to_type(
+                        builder, elem_val, elem_ptr.Ty.Pointee)
+                llvmlite.build_store(builder, store_val, elem_ptr)
+        i += 1
+
+    return 0
+
+
 @t.NoVTable
 class AnnAssignHandle(HandlesBase.Mixin):
     """AnnAssign 语句处理器：继承 Mixin 获得 Trans 回指针"""
@@ -221,6 +292,11 @@ class AnnAssignHandle(HandlesBase.Mixin):
         if HT.is_nonlocal_name(self.Trans, nm.id) != 0:
             return 0
 
+        # 模块级全局变量已由 handle_module_level_var 注册到模块作用域，
+        # 不需要创建局部 alloca（否则会导致局部变量遮蔽全局变量）
+        if HandlesVar.lookup_module_var(self.Trans.SymTab, nm.id) is not None:
+            return 0
+
         # 检查是否已存在
         existing: llvmlite.Value | t.CPtr = HandlesVar.lookup_current(
             self.Trans.SymTab, nm.id)
@@ -350,6 +426,29 @@ class AnnAssignHandle(HandlesBase.Mixin):
                         llvmlite.build_store(builder, rhs_coerced, nl_ptr)
             return 0
 
+        # 模块级全局变量（由 handle_module_level_var 注册到模块作用域）
+        # 非函数内 global 声明，但变量已在模块作用域中（如模块级 t.CArray 初始化）
+        mod_glob: llvmlite.Value | t.CPtr = HandlesVar.lookup_module_var(
+            self.Trans.SymTab, nm.id)
+        if mod_glob is not None:
+            if aa.value is not None:
+                # 列表字面量 → 逐元素 GEP + store 初始化数组
+                if aa.value.kind() == ast.ASTKind.List:
+                    _init_global_array_from_list(
+                        builder, pool, mod, mod_glob, aa.value, self.Trans)
+                else:
+                    rhs_val_mg: llvmlite.Value | t.CPtr = HandlesExpr.translate_value(
+                        builder, pool, mod, aa.value,
+                        None, 0, self.Trans)
+                    if rhs_val_mg is not None:
+                        target_ty_mg: llvmlite.LLVMType | t.CPtr = None
+                        if mod_glob.Ty is not None:
+                            target_ty_mg = mod_glob.Ty.Pointee
+                        if target_ty_mg is not None:
+                            rhs_val_mg = HandlesExpr.coerce_to_type(builder, rhs_val_mg, target_ty_mg)
+                        llvmlite.build_store(builder, rhs_val_mg, mod_glob)
+            return 0
+
         # 普通局部变量
         # 创建 alloca
         alloca: llvmlite.Value | t.CPtr = HandlesVar.get_or_create_sym(