修正了部分代码的表达方式，最后可用版本，正在为 mlirlite 做准备

App/lib/Phase/BuildPipeline.vp

@@ -34,7 +34,7 @@ import lib.Stub.StubMerger.StubMergerCollect as StubMergerCollect
 # ============================================================
 
 # 全局 mbuddy 指针
-_mbuddy: rawptr[memhub.MemBuddy]
+_mbuddy: memhub.MemBuddy*
 
 # ASan 模式（--asan）：对 .ll 先 opt -passes=asan 插桩；ASan 运行库由
 # project.vpj 的 linker.static_libs / dynamic_libs 显式声明（TPV 不注入）
@@ -61,7 +61,7 @@ PYI_BUF_SIZE: sizet = 262144
 # Args: mb 内存池；file_path 源文件路径；sha1_val 文件内容的 SHA1 前16字符（用于函数名混淆）；current_package 当前文件所属包名（用于解析相对导入），None 表示顶级模块；declare_only 0=全量翻译（默认），1=仅注册 struct/enum/union（不翻译方法体）；temp_dir temp 目录路径（非 None 时在翻译前生成 .vpi 存根文件）
 # Returns: Translator 对象（None 失败）
 # ============================================================
-def TranslateFileGetTrans(mb: rawptr[memhub.MemBuddy], file_path: str,
+def TranslateFileGetTrans(mb: memhub.MemBuddy*, file_path: str,
                           sha1_val: str,
                           current_package: str = None,
                           declare_only: int = 0,
@@ -92,10 +92,10 @@ def TranslateFileGetTrans(mb: rawptr[memhub.MemBuddy], file_path: str,
         return None
     if bytes_read < SRC_BUF_SIZE:
         src_buf[bytes_read] = 0
-    lx: rawptr[ast.Lexer] = ast.new_lexer(mb)
+    lx: ast.Lexer* = ast.new_lexer(mb)
     ast._lexer_init(lx, src_buf, mb)
-    tokens: rawptr[ast.Token] = ast.tokenize(lx)
-    tree: rawptr[ast.AST] = ast.parse_tokens(mb, tokens)
+    tokens: ast.Token* = ast.tokenize(lx)
+    tree: ast.AST* = ast.parse_tokens(mb, tokens)
     # parse 完成后 AST 树已独立，释放源代码缓冲区（避免 1MB/文件泄漏）
     stdlib.free(src_buf)
     if tree is None:
@@ -585,7 +585,7 @@ def run_llc_parallel(tasks: bytes, task_count: int, max_threads: int) -> int:
         max_threads = 1
     # 线程句柄数组：list[str]（str=bytes=i8*，elem_size=8 显式）存句柄值；list[t.CPtr] 特化下 append 会读零页崩溃（原因待查），list[str] 全库验证稳定。
     # start() 后立即取 handle 存入，join/close 直接对句柄操作，不依赖 Thread 对象存续。
-    handles: list[str] | t.CPtr = list[str](_mbuddy, 8)
+    handles: list[str]* = list[str](_mbuddy, 8)
     if handles is None:
         VLogger.error("run_llc_parallel: 线程句柄数组分配失败", "PhaseB")
         return 1

App/lib/Phase/Phase1/Phase1Main.vp

@@ -234,7 +234,7 @@ def _BreakContainerCyclesInDeps(temp_dir: str) -> int:
 # Args: mb 内存池；includes_dir includes 根目录（仅用于失败诊断，路径以 store 为准）
 # Returns: ScanResult 指针（stdlib 分配，调用方负责释放）；失败返回 None
 # ============================================================
-def _BuildReachableResult(mb: rawptr[memhub.MemBuddy],
+def _BuildReachableResult(mb: memhub.MemBuddy*,
                           includes_dir: str) -> rawptr[IncludesScanner.ScanResult]:
     """从 Sha1Store（仅可达 includes + App）构建可达 FileEntry 列表"""
     if mb is None:
@@ -318,7 +318,7 @@ def _BuildReachableResult(mb: rawptr[memhub.MemBuddy],
 # Args: mb 内存池；includes_dir includes 目录路径；temp_dir 临时目录（保存 stub）；log 日志器
 # Returns: 0 成功，非 0 失败
 # ============================================================
-def RunPhase1(mb: rawptr[memhub.MemBuddy], includes_dir: str, temp_dir: str,
+def RunPhase1(mb: memhub.MemBuddy*, includes_dir: str, temp_dir: str,
               log: rawptr[VLogger.Logger]) -> int:
     """Phase1: 扫描 includes 目录，按需翻译并生成 stub"""
     if includes_dir is None or temp_dir is None:
@@ -609,14 +609,14 @@ def RunPhase1(mb: rawptr[memhub.MemBuddy], includes_dir: str, temp_dir: str,
             src_buf_r[bytes_read_r] = 0
 
         # 解析 AST
-        lx_r: rawptr[ast.Lexer] = ast.new_lexer(mb)
+        lx_r: ast.Lexer* = ast.new_lexer(mb)
         if lx_r is None:
             stdlib.free(src_buf_r)
             p1a_fl += 1
             continue
         ast._lexer_init(lx_r, src_buf_r, mb)
-        tokens_r: rawptr[ast.Token] = ast.tokenize(lx_r)
-        tree_r: rawptr[ast.AST] = ast.parse_tokens(mb, tokens_r)
+        tokens_r: ast.Token* = ast.tokenize(lx_r)
+        tree_r: ast.AST* = ast.parse_tokens(mb, tokens_r)
         if tree_r is None:
             stdlib.free(src_buf_r)
             p1a_fl += 1
@@ -767,15 +767,15 @@ def RunPhase1(mb: rawptr[memhub.MemBuddy], includes_dir: str, temp_dir: str,
             continue
         if bytes_read_pv < Phase1.SRC_BUF_SIZE:
             src_buf_pv[bytes_read_pv] = 0
-        lx_pv: rawptr[ast.Lexer] = ast.new_lexer(mb)
+        lx_pv: ast.Lexer* = ast.new_lexer(mb)
         if lx_pv is None:
             stdlib.free(src_buf_pv)
             p1bpre_failed += 1
             VLogger.error(f"[Phase 1b-pre] {file_path_pv} | 词法器分配失败（OOM）", "Phase1")
             continue
         ast._lexer_init(lx_pv, src_buf_pv, mb)
-        tokens_pv: rawptr[ast.Token] = ast.tokenize(lx_pv)
-        tree_pv: rawptr[ast.AST] = ast.parse_tokens(mb, tokens_pv)
+        tokens_pv: ast.Token* = ast.tokenize(lx_pv)
+        tree_pv: ast.AST* = ast.parse_tokens(mb, tokens_pv)
         if tree_pv is None:
             stdlib.free(src_buf_pv)
             p1bpre_failed += 1
@@ -972,14 +972,14 @@ def RunPhase1(mb: rawptr[memhub.MemBuddy], includes_dir: str, temp_dir: str,
             src_buf[bytes_read] = 0
 
         # 解析 AST
-        lx: rawptr[ast.Lexer] = ast.new_lexer(mb)
+        lx: ast.Lexer* = ast.new_lexer(mb)
         if lx is None:
             stdlib.free(src_buf)
             failed += 1
             continue
         ast._lexer_init(lx, src_buf, mb)
-        tokens: rawptr[ast.Token] = ast.tokenize(lx)
-        tree: rawptr[ast.AST] = ast.parse_tokens(mb, tokens)
+        tokens: ast.Token* = ast.tokenize(lx)
+        tree: ast.AST* = ast.parse_tokens(mb, tokens)
         if tree is None:
             VLogger.error(f"AST 解析失败: {file_path}", "Phase1")
             stdlib.free(src_buf)

App/lib/Phase/Phase1/Phase1Scan.vp

@@ -53,7 +53,7 @@ import lib.core.Gen.GenApi as GenApi
 #       parent_names_buf 父类名扁平数组（每个 Phase1.CLASS_NAME_LEN 字节，无父类填 '\0'）；def_sha1s_buf 定义 SHA1 扁平数组（每个 Phase1.SHA1_LEN 字节）
 # Returns: 收集到的类数量，-1 失败
 # ============================================================
-def _ScanClassInheritance(mb: rawptr[memhub.MemBuddy],
+def _ScanClassInheritance(mb: memhub.MemBuddy*,
                           result: rawptr[IncludesScanner.ScanResult],
                           reachable_set: str, reachable_count: int,
                           use_reachable: int,
@@ -121,13 +121,13 @@ def _ScanClassInheritance(mb: rawptr[memhub.MemBuddy],
             src_buf[bytes_read] = 0
 
         # 解析 AST
-        lx: rawptr[ast.Lexer] = ast.new_lexer(mb)
+        lx: ast.Lexer* = ast.new_lexer(mb)
         if lx is None:
             stdlib.free(src_buf)
             continue
         ast._lexer_init(lx, src_buf, mb)
-        tokens: rawptr[ast.Token] = ast.tokenize(lx)
-        tree: rawptr[ast.AST] = ast.parse_tokens(mb, tokens)
+        tokens: ast.Token* = ast.tokenize(lx)
+        tree: ast.AST* = ast.parse_tokens(mb, tokens)
         if tree is None:
             stdlib.free(src_buf)
             continue
@@ -137,20 +137,20 @@ def _ScanClassInheritance(mb: rawptr[memhub.MemBuddy],
         if ch is not None:
             cn: sizet = len(ch)
             for ci in range(cn):
-                child: rawptr[ast.AST] = ch.get(ci)
+                child: ast.AST* = ch.get(ci)
                 if child is None:
                     continue
                 kd: int = child.kind()
                 if kd != ast.ASTKind.ClassDef:
                     continue
 
-                cd: rawptr[ast.ClassDef] = rawptr[ast.ClassDef](child)
+                cd: ast.ClassDef* = ast.ClassDef*(child)
                 if cd is None or cd.name is None:
                     continue
 
                 # 检测泛型类（有 type_params），记录文件索引以供 Phase 1a 预注册
                 if file_has_generic == 0:
-                    tp_scan: list[str] | t.CPtr = cd.type_params
+                    tp_scan: list[str]* = cd.type_params
                     if tp_scan is not None:
                         file_has_generic = 1
                         if generic_file_count_box is not None:
@@ -252,12 +252,12 @@ def _BufHasGenericClassMarker(buf: bytes, blen: sizet) -> int:
 # _find_generic_template 遍历悬空内存 strcmp 崩溃。本函数先文本扫描（_BufHasGenericClassMarker，不 parse）筛选出含泛型类的文件，
 # 仅对命中文件用**永久池（perm_pool）**解析（模板节点与表直接进 perm_pool，跨 mark 永久存活、不占主 pool）；重复注册由 _register_generic_template 内部查重跳过。
 # ============================================================
-def _PreRegisterAllGenericTemplates(mb: rawptr[memhub.MemBuddy],
+def _PreRegisterAllGenericTemplates(mb: memhub.MemBuddy*,
                                     result: rawptr[IncludesScanner.ScanResult]) -> int:
     """预注册全部 includes 文件的泛型类模板，返回处理到的泛型类数量"""
     if result is None or mb is None:
         return 0
-    perm: rawptr[memhub.MemBuddy] = CompilerFactory.factory.PermPool
+    perm: memhub.MemBuddy* = CompilerFactory.factory.PermPool
     if perm is None:
         return 0
     p1e_size: sizet = IncludesScanner.FileEntry.__sizeof__()
@@ -294,13 +294,13 @@ def _PreRegisterAllGenericTemplates(mb: rawptr[memhub.MemBuddy],
             stdlib.free(src_buf_pg)
             continue
         # 泛型文件：永久池解析 → 注册模板（节点/表进 perm_pool，跨 reset 存活）
-        lx_pg: rawptr[ast.Lexer] = ast.new_lexer(perm)
+        lx_pg: ast.Lexer* = ast.new_lexer(perm)
         if lx_pg is None:
             stdlib.free(src_buf_pg)
             continue
         ast._lexer_init(lx_pg, src_buf_pg, perm)
-        tokens_pg: rawptr[ast.Token] = ast.tokenize(lx_pg)
-        tree_pg: rawptr[ast.AST] = ast.parse_tokens(perm, tokens_pg)
+        tokens_pg: ast.Token* = ast.tokenize(lx_pg)
+        tree_pg: ast.AST* = ast.parse_tokens(perm, tokens_pg)
         if tree_pg is None:
             stdlib.free(src_buf_pg)
             continue
@@ -309,13 +309,13 @@ def _PreRegisterAllGenericTemplates(mb: rawptr[memhub.MemBuddy],
         if ch_pg is not None:
             cn_pg: sizet = len(ch_pg)
             for ci_pg in range(cn_pg):
-                child_pg: rawptr[ast.AST] = ch_pg.get(ci_pg)
+                child_pg: ast.AST* = ch_pg.get(ci_pg)
                 if child_pg is None or child_pg.kind() != ast.ASTKind.ClassDef:
                     continue
-                cd_pg: rawptr[ast.ClassDef] = rawptr[ast.ClassDef](child_pg)
+                cd_pg: ast.ClassDef* = ast.ClassDef*(child_pg)
                 if cd_pg is None or cd_pg.name is None:
                     continue
-                tp_pg: list[str] | t.CPtr = cd_pg.type_params
+                tp_pg: list[str]* = cd_pg.type_params
                 if tp_pg is None:
                     continue
                 GenApi.set_current_file_type(file_path_pg)
@@ -351,7 +351,7 @@ def _FindClassDefSha1(class_names_buf: bytes, def_sha1s_buf: bytes,
 # 命中即置 need_list/need_dict；误报无害（最多多编译两个空壳模块）。
 # ============================================================
 
-def _AnnIsContainer(ann: rawptr[ast.AST]) -> int:
+def _AnnIsContainer(ann: ast.AST*) -> int:
     """注解是否为 list/dict 容器（Name 裸名或 Subscript list[...]/dict[...]）
 
     数组初始化（t.CArray[...] / 裸数组注解）返回 0，避免 _ScanTreeForContainers
@@ -360,7 +360,7 @@ def _AnnIsContainer(ann: rawptr[ast.AST]) -> int:
     while ann is not None:
         ak_c: int = ann.kind()
         if ak_c == ast.ASTKind.Name:
-            nm_c: rawptr[ast.Name] = rawptr[ast.Name](ann)
+            nm_c: ast.Name* = ast.Name*(ann)
             if nm_c.id is not None:
                 if string.strcmp(nm_c.id, "list") == 0:
                     return 1
@@ -368,14 +368,14 @@ def _AnnIsContainer(ann: rawptr[ast.AST]) -> int:
                     return 1
             return 0
         elif ak_c == ast.ASTKind.Subscript:
-            sub_c: rawptr[ast.Subscript] = rawptr[ast.Subscript](ann)
+            sub_c: ast.Subscript* = ast.Subscript*(ann)
             ann = sub_c.value
         else:
             return 0
     return 0
 
 
-def _ScanTreeForContainers(node: rawptr[ast.AST],
+def _ScanTreeForContainers(node: ast.AST*,
                            need_list_box: t.CPtr,
                            need_dict_box: t.CPtr,
                            depth: int = 0):
@@ -388,22 +388,22 @@ def _ScanTreeForContainers(node: rawptr[ast.AST],
         return
     k_s: int = node.kind()
     if k_s == ast.ASTKind.Name:
-        nm_s: rawptr[ast.Name] = rawptr[ast.Name](node)
+        nm_s: ast.Name* = ast.Name*(node)
         if nm_s.id is not None:
             if string.strcmp(nm_s.id, "list") == 0:
                 need_list_box[0] = 1
             elif string.strcmp(nm_s.id, "dict") == 0:
                 need_dict_box[0] = 1
     elif k_s == ast.ASTKind.Subscript:
-        sub_s: rawptr[ast.Subscript] = rawptr[ast.Subscript](node)
+        sub_s: ast.Subscript* = ast.Subscript*(node)
         _ScanTreeForContainers(sub_s.value, need_list_box, need_dict_box, depth + 1)
         _ScanTreeForContainers(sub_s.slice, need_list_box, need_dict_box, depth + 1)
     elif k_s == ast.ASTKind.BinOp:
-        bop_s: rawptr[ast.BinOp] = rawptr[ast.BinOp](node)
+        bop_s: ast.BinOp* = ast.BinOp*(node)
         _ScanTreeForContainers(bop_s.left, need_list_box, need_dict_box, depth + 1)
         _ScanTreeForContainers(bop_s.right, need_list_box, need_dict_box, depth + 1)
     elif k_s == ast.ASTKind.Call:
-        cl_s2: rawptr[ast.Call] = rawptr[ast.Call](node)
+        cl_s2: ast.Call* = ast.Call*(node)
         _ScanTreeForContainers(cl_s2.func, need_list_box, need_dict_box, depth + 1)
         cl_args_s: list[ast.AST*]* = cl_s2.args
         if cl_args_s is not None:
@@ -420,7 +420,7 @@ def _ScanTreeForContainers(node: rawptr[ast.AST],
                 if kw_s is not None:
                     _ScanTreeForContainers(kw_s.value, need_list_box, need_dict_box, depth + 1)
     elif k_s == ast.ASTKind.Assign:
-        asn_s: rawptr[ast.Assign] = rawptr[ast.Assign](node)
+        asn_s: ast.Assign* = ast.Assign*(node)
         _ScanTreeForContainers(asn_s.value, need_list_box, need_dict_box, depth + 1)
         tgts_s: list[ast.AST*]* = asn_s.targets
         if tgts_s is not None:
@@ -429,24 +429,24 @@ def _ScanTreeForContainers(node: rawptr[ast.AST],
             for i_t2 in range(nt_s):
                 _ScanTreeForContainers(tgts_s.get(i_t2), need_list_box, need_dict_box, depth + 1)
     elif k_s == ast.ASTKind.AnnAssign:
-        aa_s2: rawptr[ast.AnnAssign] = rawptr[ast.AnnAssign](node)
+        aa_s2: ast.AnnAssign* = ast.AnnAssign*(node)
         _ScanTreeForContainers(aa_s2.annotation, need_list_box, need_dict_box, depth + 1)
         _ScanTreeForContainers(aa_s2.value, need_list_box, need_dict_box, depth + 1)
     elif k_s == ast.ASTKind.FunctionDef:
-        fn_s: rawptr[ast.FunctionDef] = rawptr[ast.FunctionDef](node)
+        fn_s: ast.FunctionDef* = ast.FunctionDef*(node)
         _ScanTreeForContainers(fn_s.returns, need_list_box, need_dict_box, depth + 1)
-        fn_args_s: rawptr[ast.Arguments] = rawptr[ast.Arguments](fn_s.args)
+        fn_args_s: ast.Arguments* = ast.Arguments*(fn_s.args)
         if fn_args_s is not None:
             fa_s: list[ast.AST*]* = fn_args_s.args
             if fa_s is not None:
                 nf_s: sizet = len(fa_s)
                 i_f2: sizet
                 for i_f2 in range(nf_s):
-                    arg_s: rawptr[ast.Arg] = rawptr[ast.Arg](fa_s.get(i_f2))
+                    arg_s: ast.Arg* = ast.Arg*(fa_s.get(i_f2))
                     if arg_s is not None:
                         _ScanTreeForContainers(arg_s.annotation, need_list_box, need_dict_box, depth + 1)
     elif k_s == ast.ASTKind.ClassDef:
-        cd_s: rawptr[ast.ClassDef] = rawptr[ast.ClassDef](node)
+        cd_s: ast.ClassDef* = ast.ClassDef*(node)
         bases_s: list[ast.AST*]* = cd_s.bases
         if bases_s is not None:
             nb_s: sizet = len(bases_s)
@@ -454,10 +454,10 @@ def _ScanTreeForContainers(node: rawptr[ast.AST],
             for i_b2 in range(nb_s):
                 _ScanTreeForContainers(bases_s.get(i_b2), need_list_box, need_dict_box, depth + 1)
     elif k_s == ast.ASTKind.Attribute:
-        at_s: rawptr[ast.Attribute] = rawptr[ast.Attribute](node)
+        at_s: ast.Attribute* = ast.Attribute*(node)
         _ScanTreeForContainers(at_s.value, need_list_box, need_dict_box, depth + 1)
     elif k_s == ast.ASTKind.Tuple:
-        tu_s: rawptr[ast.Tuple] = rawptr[ast.Tuple](node)
+        tu_s: ast.Tuple* = ast.Tuple*(node)
         elts_s: list[ast.AST*]* = tu_s.elts
         if elts_s is not None:
             ne_s: sizet = len(elts_s)
@@ -465,7 +465,7 @@ def _ScanTreeForContainers(node: rawptr[ast.AST],
             for i_e2 in range(ne_s):
                 _ScanTreeForContainers(elts_s.get(i_e2), need_list_box, need_dict_box, depth + 1)
     elif k_s == ast.ASTKind.UnaryOp:
-        uop_s: rawptr[ast.UnaryOp] = rawptr[ast.UnaryOp](node)
+        uop_s: ast.UnaryOp* = ast.UnaryOp*(node)
         _ScanTreeForContainers(uop_s.operand, need_list_box, need_dict_box, depth + 1)
     elif k_s == ast.ASTKind.Expr:
         ex_s: rawptr[ast.Expr] = rawptr[ast.Expr](node)

App/lib/Phase/Phase1/Phase1Topo.vp

@@ -45,7 +45,7 @@ import lib.Phase.Phase1 as Phase1
 #       class_count 类数量；out_order 输出拓扑顺序的文件索引数组（调用者分配，int 数组）；out_count 输出文件数量
 # Returns: 0 成功，-1 失败
 # ============================================================
-def _TopoSortFiles(mb: rawptr[memhub.MemBuddy],
+def _TopoSortFiles(mb: memhub.MemBuddy*,
                    result: rawptr[IncludesScanner.ScanResult],
                    reachable_set: str, reachable_count: int,
                    use_reachable: int,

App/lib/Phase/Phase1/__init__.vp

@@ -3,7 +3,7 @@ from stdint import *
 import memhub
 
 # 全局 mbuddy 指针
-_mbuddy: rawptr[memhub.MemBuddy]
+_mbuddy: memhub.MemBuddy*
 
 # 源代码缓冲区大小（1MB）
 SRC_BUF_SIZE: t.CDefine = 1048576

App/lib/Phase/Phase2/__init__.vp

@@ -30,7 +30,7 @@ import lib.Stub.StubMerger.StubMergerTopo as StubMergerTopo
 import lib.Stub.StubGen.Converter as StubConverter
 
 # 全局 mbuddy 指针
-_mbuddy: rawptr[memhub.MemBuddy]
+_mbuddy: memhub.MemBuddy*
 
 # 源代码缓冲区大小（1MB）
 SRC_BUF_SIZE: t.CDefine = 1048576
@@ -50,7 +50,7 @@ class SrcFileEntry:
 # Args: mb 内存池；dir_path 当前扫描目录；entries SrcFileEntry 数组；entry_size 单个条目大小（SrcFileEntry.__sizeof__()）；file_count 当前已收集的文件数；max_files 最大文件数
 # Returns: 新的 file_count
 # ============================================================
-def _ScanDirForPyFiles(mb: rawptr[memhub.MemBuddy],
+def _ScanDirForPyFiles(mb: memhub.MemBuddy*,
                        dir_path: str,
                        entries: SrcFileEntry | t.CPtr,
                        entry_size: sizet,
@@ -156,7 +156,7 @@ def _ScanDirForPyFiles(mb: rawptr[memhub.MemBuddy],
 # Kernel/intr/isr.s 定义 isr0/syscall_entry/_per_cpu 等符号）。
 # TPV 不对 .s 翻译，直接用 llvm-mc 汇编为 .obj 参与链接。
 # ============================================================
-def _ScanDirForAsmFiles(mb: rawptr[memhub.MemBuddy],
+def _ScanDirForAsmFiles(mb: memhub.MemBuddy*,
                         dir_path: str,
                         entries: SrcFileEntry | t.CPtr,
                         entry_size: sizet,
@@ -256,7 +256,7 @@ def _ScanDirForAsmFiles(mb: rawptr[memhub.MemBuddy],
 # 才首次注册，reset_to(mark2) 会回收表与节点 → 后续查重/特化遍历悬空内存崩溃；App 文件数量少，mark2 前预注册的 AST 驻留内存可忽略。
 # 重复注册由 _register_generic_template 查重跳过。
 # ============================================================
-def _PreRegisterAppGenericTemplates(mb: rawptr[memhub.MemBuddy],
+def _PreRegisterAppGenericTemplates(mb: memhub.MemBuddy*,
                                     entries: SrcFileEntry | t.CPtr,
                                     file_count: int,
                                     entry_size: sizet) -> int:
@@ -290,16 +290,16 @@ def _PreRegisterAppGenericTemplates(mb: rawptr[memhub.MemBuddy],
         if bytes_read_pa < SRC_BUF_SIZE:
             src_buf_pa[bytes_read_pa] = 0
         # 解析 AST（只解析，不完整翻译；用永久池使模板节点跨 mark2 reset 存活）
-        perm_pa: rawptr[memhub.MemBuddy] = CompilerFactory.factory.PermPool
+        perm_pa: memhub.MemBuddy* = CompilerFactory.factory.PermPool
         if perm_pa is None:
             perm_pa = mb
-        lx_pa: rawptr[ast.Lexer] = ast.new_lexer(perm_pa)
+        lx_pa: ast.Lexer* = ast.new_lexer(perm_pa)
         if lx_pa is None:
             stdlib.free(src_buf_pa)
             continue
         ast._lexer_init(lx_pa, src_buf_pa, perm_pa)
-        tokens_pa: rawptr[ast.Token] = ast.tokenize(lx_pa)
-        tree_pa: rawptr[ast.AST] = ast.parse_tokens(perm_pa, tokens_pa)
+        tokens_pa: ast.Token* = ast.tokenize(lx_pa)
+        tree_pa: ast.AST* = ast.parse_tokens(perm_pa, tokens_pa)
         if tree_pa is None:
             stdlib.free(src_buf_pa)
             continue
@@ -308,13 +308,13 @@ def _PreRegisterAppGenericTemplates(mb: rawptr[memhub.MemBuddy],
         if ch_pa is not None:
             cn_pa: sizet = len(ch_pa)
             for ci_pa in range(cn_pa):
-                child_pa: rawptr[ast.AST] = ch_pa.get(ci_pa)
+                child_pa: ast.AST* = ch_pa.get(ci_pa)
                 if child_pa is None or child_pa.kind() != ast.ASTKind.ClassDef:
                     continue
-                cd_pa: rawptr[ast.ClassDef] = rawptr[ast.ClassDef](child_pa)
+                cd_pa: ast.ClassDef* = ast.ClassDef*(child_pa)
                 if cd_pa is None or cd_pa.name is None:
                     continue
-                tp_pa: list[str] | t.CPtr = cd_pa.type_params
+                tp_pa: list[str]* = cd_pa.type_params
                 if tp_pa is None:
                     continue
                 GenApi.set_current_file_type(ent_pa.Path)
@@ -608,7 +608,7 @@ def _PhaseADumpFailGraph(temp_dir: str, td_len: sizet, path: str, sha1: str) ->
     stdio.fflush(None)
 
 
-def RunMultiFileProject(mb: rawptr[memhub.MemBuddy],
+def RunMultiFileProject(mb: memhub.MemBuddy*,
                         source_dir: str, temp_dir: str, output_dir: str,
                         cc_cmd: str, cc_flags: str,
                         linker_cmd: str, linker_flags: str, linker_output: str,
@@ -793,15 +793,15 @@ def RunMultiFileProject(mb: rawptr[memhub.MemBuddy],
             continue
         if bytes_read_vp2 < SRC_BUF_SIZE:
             src_buf_vp2[bytes_read_vp2] = 0
-        lx_vp2: rawptr[ast.Lexer] = ast.new_lexer(mb)
+        lx_vp2: ast.Lexer* = ast.new_lexer(mb)
         if lx_vp2 is None:
             stdlib.free(src_buf_vp2)
             vpi_failed_p2 += 1
             VLogger.error(f"[Phase A-pre-vpi] {ent_vp2.Path} | 词法器分配失败（OOM）", "PhaseA")
             continue
         ast._lexer_init(lx_vp2, src_buf_vp2, mb)
-        tokens_vp2: rawptr[ast.Token] = ast.tokenize(lx_vp2)
-        tree_vp2: rawptr[ast.AST] = ast.parse_tokens(mb, tokens_vp2)
+        tokens_vp2: ast.Token* = ast.tokenize(lx_vp2)
+        tree_vp2: ast.AST* = ast.parse_tokens(mb, tokens_vp2)
         if tree_vp2 is None:
             stdlib.free(src_buf_vp2)
             vpi_failed_p2 += 1
@@ -1348,7 +1348,7 @@ def RunMultiFileProject(mb: rawptr[memhub.MemBuddy],
 
                 # 拓扑排序可达 includes：被依赖模块先完整翻译。跨模块 vtable 生成
                 # 需要依赖模块的函数 TypeStr 已注册到全局表（如 astaux 继承 base 的 AST）
-                topo_idx: sizet | t.CPtr = (sizet | t.CPtr)(stdlib.malloc(8 * (store_count_mi + 1)))
+                topo_idx: sizet* = (sizet*)(stdlib.malloc(8 * (store_count_mi + 1)))
                 topo_count: int = 0
                 if topo_idx is None:
                     VLogger.error("拓扑排序索引分配失败，终止编译", "PhaseB+")