from __future__ import annotations

import ast
import re
import llvmlite.ir as ir

from lib.core.LlvmCodeGenerator import LlvmCodeGenerator
from lib.core.Handles.HandlesBase import CTypeInfo
from lib.core.Handles.HandlesBase import CTypeInfo as _CTypeInfo, CTypeHelper
from lib.includes import t
from lib.constants.config import mode as _config_mode
from lib.core.VLogger import get_logger as _vlog
from lib.core.DecoratorPass import run as _run_decorator_pass
from lib.core.SymbolUtils import IsTModule, AnnotationContainsName


class LlvmGeneratorMixin:
    """LLVM IR 生成 Mixin

    提供 LLVM IR 直接生成、模块级 LLVM IR 处理与 C 代码生成入口能力。
    """

    def GenerateLlvmDirect(self, Tree: ast.Module) -> str:
        Gen: LlvmCodeGenerator = self.LlvmGen

        # === 新增：轻量 AST 遍历，收集类图信息，解决前向引用 ===
        Gen._class_graph: dict[str, dict[str, bool | list[str]]] = {}
        for Node in ast.iter_child_nodes(Tree):
            if isinstance(Node, ast.ClassDef):
                bases: list[str] = []
                for base in Node.bases:
                    if hasattr(base, 'id'):
                        bases.append(base.id)
                    elif hasattr(base, 'attr'):
                        bases.append(base.attr)
                has_methods: bool = any(isinstance(item, ast.FunctionDef) for item in Node.body)
                # 检测 @t.NoVTable 装饰器（非多态继承基类标记）
                has_novtable: bool = False
                if hasattr(Node, 'decorator_list') and Node.decorator_list:
                    for decorator in Node.decorator_list:
                        if isinstance(decorator, ast.Attribute):
                            if getattr(decorator.value, 'id', None) == 't' and decorator.attr == 'NoVTable':
                                has_novtable = True
                        elif isinstance(decorator, ast.Name):
                            if decorator.id == 'NoVTable':
                                has_novtable = True
                Gen._class_graph[Node.name] = {
                    'bases': bases,
                    'has_methods': has_methods,
                    'has_novtable': has_novtable,
                }
        # === 结束新增 ===

        # 预扫描：为所有 -> str 注解的函数注册正确的返回类型 i8*
        # 这样在类方法中调用这些函数时，前向声明会使用正确的类型
        for Node in ast.iter_child_nodes(Tree):
            if isinstance(Node, ast.FunctionDef):
                if Node.returns and isinstance(Node.returns, ast.Name) and Node.returns.id == 'str':
                    Gen.known_return_types[Node.name] = ir.PointerType(ir.IntType(8))

        # 首先收集所有 CDefine 常量，确保类定义中可以引用
        def _extract_call_const_val(node: ast.AST) -> int | str | float | None:
            if isinstance(node, ast.Call):
                if isinstance(node.func, ast.Attribute):
                    if getattr(node.func.value, 'id', None) == 't':
                        if node.args and isinstance(node.args[0], ast.Constant):
                            return node.args[0].value
                elif isinstance(node.func, ast.Name):
                    if node.args and isinstance(node.args[0], ast.Constant):
                        return node.args[0].value
            return None

        for Node in ast.iter_child_nodes(Tree):
            if isinstance(Node, ast.AnnAssign) and isinstance(Node.target, ast.Name) and Node.value:
                TypeInfo: CTypeInfo | None = self.TypeMergeHandler.GetCTypeInfo(Node.annotation)
                if TypeInfo and TypeInfo.BaseType and ((isinstance(TypeInfo.BaseType, type) and issubclass(TypeInfo.BaseType, t.CDefine)) or isinstance(TypeInfo.BaseType, t.CDefine)):
                    val: int | str | float | None = None
                    if isinstance(Node.value, ast.Constant):
                        val = Node.value.value
                    else:
                        val = _extract_call_const_val(Node.value)
                    if val is not None:
                        if not hasattr(Gen, '_define_constants'):
                            Gen._define_constants: dict[str, int | str | float | bool] = {}
                        Gen._define_constants[Node.target.id] = val
                        existing = self.SymbolTable.lookup(Node.target.id)
                        if not (existing and existing.IsTypedef and existing.OriginalType):
                            sym_info: _CTypeInfo = _CTypeInfo()
                            sym_info.IsDefine = True
                            sym_info.DefineValue = val
                            self.SymbolTable.insert(Node.target.id, sym_info)
            elif isinstance(Node, ast.Assign):
                for target in Node.targets:
                    if isinstance(target, ast.Name):
                        TypeInfo: CTypeInfo | None = None
                        if Node.type_comment:
                            try:
                                tc_ast: ast.Expression = ast.parse(Node.type_comment, mode='eval')
                                TypeInfo = self.TypeMergeHandler.GetCTypeInfo(tc_ast.body)
                            except Exception as _e:
                                if _config_mode == "strict":
                                    raise
                                _vlog().warning(f"解析类型注释失败: {_e}", "Exception")
                        if TypeInfo and TypeInfo.BaseType and ((isinstance(TypeInfo.BaseType, type) and issubclass(TypeInfo.BaseType, t.CDefine)) or isinstance(TypeInfo.BaseType, t.CDefine)):
                            val: int | str | float | None = None
                            if isinstance(Node.value, ast.Constant):
                                val = Node.value.value
                            else:
                                val = _extract_call_const_val(Node.value)
                            if val is not None:
                                if not hasattr(Gen, '_define_constants'):
                                    Gen._define_constants: dict[str, int | str | float | bool] = {}
                                Gen._define_constants[target.id] = val
                                sym_info: _CTypeInfo = _CTypeInfo()
                                sym_info.IsDefine = True
                                sym_info.DefineValue = val
                                self.SymbolTable.insert(target.id, sym_info)

        # 预扫描所有顶层函数定义，填充 FunctionDefCache（不创建 LLVM 声明）
        # 这样类方法编译时遇到未声明的函数可以按需前向声明
        for Node in ast.iter_child_nodes(Tree):
            if isinstance(Node, ast.FunctionDef):
                FuncName: str = Node.name
                if FuncName not in self.FunctionDefCache:
                    self.FunctionDefCache[FuncName] = Node

        # 首先处理所有导入语句，确保模块在类型解析前被加载
        for Node in ast.iter_child_nodes(Tree):
            Gen._set_node_info(Node)
            try:
                if isinstance(Node, ast.Import):
                    self.ImportHandler._EmitImportDeclarationsLlvm(Node, Gen)
                elif isinstance(Node, ast.ImportFrom):
                    self.ImportHandler._EmitImportFromDeclarationsLlvm(Node, Gen)
            except Exception as e:
                lineno: int = getattr(Node, 'lineno', 0)
                source_line: str | None = Gen._get_source_line(lineno)
                src_file: str = getattr(Gen, '_current_source_file', '')
                src_path: str = src_file if src_file else 'unknown'
                line_info: str = "源代码 (%s, line %d)" % (src_path, lineno)
                if source_line:
                    line_info += ":\n    %d | %s" % (lineno, source_line)
                self._ErrorStack.append((type(e).__name__, str(e), line_info))

        # 前向声明所有顶层函数，确保全局变量初始化时能引用函数指针
        for Node in ast.iter_child_nodes(Tree):
            if isinstance(Node, ast.FunctionDef):
                Gen._set_node_info(Node)
                self.FunctionHandler._EmitFunctionForwardDeclLlvm(Node, Gen)

        # 预创建全局变量（带初始化器），确保类方法编译时能引用全局数组等
        Gen._current_tree: ast.Module = Tree
        for Node in ast.iter_child_nodes(Tree):
            Gen._set_node_info(Node)
            if isinstance(Node, ast.AnnAssign):
                self.AssignHandler._EmitGlobalAnnAssignLlvm(Node, Gen)
            elif isinstance(Node, ast.Assign):
                self.AssignHandler._EmitGlobalAssignLlvm(Node, Gen)

        # 首先处理所有类定义（包括 CUnion），确保类型定义在使用前完成
        for Node in ast.iter_child_nodes(Tree):
            if isinstance(Node, ast.ClassDef):
                Gen._set_node_info(Node)
                self.ClassHandler._EmitClassLlvm(Node, Gen)

        Gen._generate_structs()
        Gen._create_Vtable_globals()

        for Node in ast.iter_child_nodes(Tree):
            Gen._set_node_info(Node)
            try:
                if isinstance(Node, ast.Import):
                    continue
                elif isinstance(Node, ast.ImportFrom):
                    continue
                elif isinstance(Node, ast.ClassDef):
                    continue
                elif isinstance(Node, ast.FunctionDef):
                    self.FunctionHandler._EmitFunctionLlvm(Node, Gen)
                elif isinstance(Node, ast.AnnAssign):
                    self.AssignHandler._EmitGlobalAnnAssignLlvm(Node, Gen)
                elif isinstance(Node, ast.Assign):
                    self.AssignHandler._EmitGlobalAssignLlvm(Node, Gen)
                elif isinstance(Node, ast.If):
                    pass
                elif isinstance(Node, ast.Expr):
                    self._HandleModuleLevelExprLlvm(Node, Gen)
            except Exception as e:
                lineno: int = getattr(Node, 'lineno', 0)
                source_line: str | None = Gen._get_source_line(lineno)
                src_file: str = getattr(Gen, '_current_source_file', '')
                src_path: str = src_file if src_file else 'unknown'
                line_info: str = "源代码 (%s, line %d)" % (src_path, lineno)
                if source_line:
                    line_info += ":\n    %d | %s" % (lineno, source_line)
                self._ErrorStack.append((type(e).__name__, str(e), line_info))
                raise
        Gen._set_Vtable_initializers()
        # 执行 DecoratorPass：为带自定义装饰器的函数生成 wrapper
        _run_decorator_pass(Gen)
        ir_code: str = Gen.finalize()
        return ir_code

    def _HandleModuleLevelExprLlvm(self, Node: ast.Expr, Gen: LlvmCodeGenerator) -> None:
        if not isinstance(Node.value, ast.Call):
            return
        call: ast.Call = Node.value
        if not isinstance(call.func, ast.Attribute):
            return
        if not isinstance(call.func.value, ast.Name) or call.func.value.id != 'c':
            return
        func_name: str = call.func.attr
        if func_name == 'LLVMIR':
            self._HandleModuleLevelLLVMIR(call, Gen)

    def _HandleModuleLevelLLVMIR(self, Node: ast.Call, Gen: LlvmCodeGenerator) -> None:
        if not Node.args:
            return
        first_arg: ast.expr = Node.args[0]
        if isinstance(first_arg, ast.Constant) and isinstance(first_arg.value, str):
            ir_text: str = first_arg.value
        elif isinstance(first_arg, ast.JoinedStr):
            parts: list[str] = []
            for value in first_arg.values:
                if isinstance(value, ast.Constant) and isinstance(value.value, str):
                    parts.append(value.value)
                elif isinstance(value, ast.FormattedValue):
                    parts.append('')
            ir_text = ''.join(parts)
        else:
            return
        self._InsertModuleLevelLLVMIR(Gen, ir_text)

    def _InsertModuleLevelLLVMIR(self, Gen: LlvmCodeGenerator, ir_text: str) -> None:
        for line in ir_text.strip().split('\n'):
            line = line.strip()
            if not line:
                continue
            module_flags_match: re.Match[str] | None = re.match(r'!llvm\.module\.flags\s*=\s*!\{(!\d+)\}', line)
            if module_flags_match:
                ref: str = module_flags_match.group(1)
                if not hasattr(Gen, '_pending_module_flags'):
                    Gen._pending_module_flags: list = []
                Gen._pending_module_flags_refs: str = ref
                continue
            metadata_match: re.Match[str] | None = re.match(r'(!\d+)\s*=\s*!\{(.+)\}', line)
            if metadata_match:
                md_id: str = metadata_match.group(1)
                md_body: str = metadata_match.group(2)
                fields: list[ir.Constant | ir.MetaDataString | str] = []
                for field_str in re.split(r',\s*', md_body):
                    field_str = field_str.strip()
                    if not field_str:
                        continue
                    int_m: re.Match[str] | None = re.match(r'^i32\s+(\d+)$', field_str)
                    if int_m:
                        fields.append(ir.Constant(ir.IntType(32), int(int_m.group(1))))
                        continue
                    str_m: re.Match[str] | None = re.match(r'^"([^"]*)"$', field_str)
                    if str_m:
                        fields.append(ir.MetaDataString(Gen.module, str_m.group(1)))
                        continue
                    mdstr_m: re.Match[str] | None = re.match(r'^!"([^"]*)"$', field_str)
                    if mdstr_m:
                        fields.append(ir.MetaDataString(Gen.module, mdstr_m.group(1)))
                        continue
                    int_m2: re.Match[str] | None = re.match(r'^(\d+)$', field_str)
                    if int_m2:
                        fields.append(ir.Constant(ir.IntType(32), int(int_m2.group(1))))
                        continue
                    ref_m: re.Match[str] | None = re.match(r'^(!\d+)$', field_str)
                    if ref_m:
                        fields.append(ref_m.group(1))
                        continue
                if fields:
                    if not hasattr(Gen, '_pending_metadata'):
                        Gen._pending_metadata: list[tuple[str, list]] = []
                    Gen._pending_metadata.append((md_id, fields))
                continue
        self._FlushModuleMetadata(Gen)

    def _FlushModuleMetadata(self, Gen: LlvmCodeGenerator) -> None:
        if not hasattr(Gen, '_pending_metadata') or not Gen._pending_metadata:
            return
        md_map: dict[str, ir.MetaDataString] = {}
        for md_id, fields in Gen._pending_metadata:
            resolved: list[ir.Constant | ir.MetaDataString] = []
            for f in fields:
                if isinstance(f, str) and f.startswith('!'):
                    ref: ir.MetaDataString | None = md_map.get(f)
                    if ref:
                        resolved.append(ref)
                else:
                    resolved.append(f)
            md_value: ir.MetaDataString = Gen.module.add_metadata(resolved)
            md_map[md_id] = md_value
        if hasattr(Gen, '_pending_module_flags_refs'):
            ref: str = Gen._pending_module_flags_refs
            md_node: ir.MetaDataString | None = md_map.get(ref)
            if md_node:
                Gen.module.add_named_metadata('llvm.module.flags', md_node)
        Gen._pending_metadata = []
        Gen._pending_module_flags_refs = None

    def GenerateCCode(self, Tree: ast.Module, target: str = 'llvm') -> str:
        """生成代码

        Args:
            Tree: Python AST 树
            target: 目标代码类型，仅支持 'llvm'

        Returns:
            生成的代码字符串
        """
        self._generated_vars: set[str] = set()
        self.VarScopes = [{}]  # 全局作用域

        # 预扫描 import 语句，注册别名，确保类型解析时能正确解析模块别名
        if not getattr(self, '_ImportedModules', None):
            self._ImportedModules: set[str] = set()
        for Node in ast.iter_child_nodes(Tree):
            if isinstance(Node, ast.Import):
                for alias in Node.names:
                    name: str = alias.name
                    if name in ('c', 't'):
                        continue
                    self._ImportedModules.add(name)
                    if alias.asname:
                        self.SymbolTable.import_aliases[alias.asname] = name
            elif isinstance(Node, ast.ImportFrom):
                module_name: str | None = Node.module
                if module_name and module_name not in ('c', 't'):
                    self._ImportedModules.add(module_name)
                    for alias in Node.names:
                        if alias.asname:
                            self.SymbolTable.import_aliases[alias.asname] = f"{module_name}.{alias.name}"

        for Node in ast.iter_child_nodes(Tree):
            if isinstance(Node, ast.ClassDef):
                ClassName: str = Node.name

                # 检查是否是特殊类型（枚举或联合体）
                IsSpecialType: bool = False
                if Node.bases:
                    for base in Node.bases:
                        if hasattr(base, 'attr'):
                            if base.attr in ['CEnum', 'Enum', 'CUnion', 'REnum']:
                                IsSpecialType = True
                                break
                        elif hasattr(base, 'id'):
                            if base.id in ['CEnum', 'Enum', 'CUnion', 'REnum']:
                                IsSpecialType = True
                                break

                # 如果是特殊类型，跳过这里的处理（由 HandleClassDef 处理）
                if IsSpecialType:
                    continue

                members: dict[str, CTypeInfo] = {}
                IsTypedef: bool = False
                TypedefName: str | None = None

                if hasattr(Node, 'annotation') and Node.annotation:
                    try:
                        if AnnotationContainsName(Node.annotation, 'CTypedef'):
                            IsTypedef = True
                            if isinstance(Node.annotation, ast.Call):
                                if Node.annotation.args:
                                    if isinstance(Node.annotation.args[0], ast.Constant):
                                        TypedefName = Node.annotation.args[0].value
                    except Exception as _e:
                        if _config_mode == "strict":
                            raise
                        _vlog().warning(f"解析 typedef 注解失败: {_e}", "Exception")

                if not IsTypedef:
                    for item in Node.body:
                        if isinstance(item, ast.Assign):
                            for target in item.targets:
                                if isinstance(target, ast.Name) and target.id == '__annotations__':
                                    if isinstance(item.value, ast.Dict):
                                        for key, value in zip(item.value.keys, item.value.values):
                                            if isinstance(key, ast.Constant) and key.value == '__type__':
                                                if AnnotationContainsName(value, 'CTypedef'):
                                                    IsTypedef = True

                if IsTypedef:
                    TypedefKey: str = TypedefName if TypedefName else ClassName
                    TypedefNode: CTypeInfo = CTypeInfo()
                    TypedefNode.Name = TypedefKey
                    TypedefNode.IsTypedef = True
                    TypedefNode.OriginalType = f'struct {ClassName}'
                    TypedefNode.set('IsComplete', True)
                    TypedefNode.file = '<stdin>'
                    self.SymbolTable.insert(TypedefKey, TypedefNode)

                for item in Node.body:
                    if isinstance(item, ast.AnnAssign) and isinstance(item.target, ast.Name):
                        VarName: str = item.target.id
                        try:
                            TypeInfo: CTypeInfo | None = self.TypeMergeHandler.GetCTypeInfo(item.annotation)
                            if TypeInfo is None:
                                TypeInfo = CTypeInfo()
                                TypeInfo.BaseType = t.CInt()
                            IsPtr: bool = TypeInfo.IsPtr
                            if not IsPtr:
                                if isinstance(item.annotation, ast.BinOp) and isinstance(item.annotation.op, ast.BitOr):
                                    if AnnotationContainsName(item.annotation, 'CPtr'):
                                        IsPtr = True
                            dims: list[int] = []
                            if hasattr(item.annotation, 'slice') and isinstance(item.annotation.slice, ast.Constant):
                                if isinstance(item.annotation.value, ast.Name):
                                    if IsTModule(item.annotation.value.id, self.SymbolTable):
                                        if hasattr(item.annotation, 'slice'):
                                            try:
                                                dims.append(int(item.annotation.slice.value))
                                            except Exception as _e:
                                                if _config_mode == "strict":
                                                    self.LogWarning(f"异常被忽略: {_e}")
                            MemberInfo: CTypeInfo = TypeInfo.Copy()
                            if dims:
                                MemberInfo.ArrayDims = [str(d) for d in dims]
                            members[VarName] = MemberInfo
                        except Exception as _e:
                            if _config_mode == "strict":
                                self.LogWarning(f"异常被忽略: {_e}")

                if not IsTypedef:
                    StructNode: CTypeInfo = CTypeInfo()
                    StructNode.Name = ClassName
                    StructNode.IsStruct = True
                    StructNode.Members = members or {}
                    StructNode.file = '<stdin>'
                    existing: CTypeInfo | None = self.SymbolTable.lookup(ClassName)
                    if existing:
                        if hasattr(existing, 'IsCpythonObject') and existing.IsCpythonObject:
                            StructNode.IsCpythonObject = True
                    self.SymbolTable.insert(ClassName, StructNode)
            elif isinstance(Node, ast.FunctionDef):
                FuncName: str = Node.name
                if not self.SymbolTable.has(FuncName):
                    FuncNode: CTypeInfo = CTypeInfo()
                    FuncNode.Name = FuncName
                    FuncNode.IsFunction = True
                    FuncNode.file = '<stdin>'
                    self.SymbolTable.insert(FuncName, FuncNode)
            elif isinstance(Node, ast.AnnAssign):
                if isinstance(Node.target, ast.Name):
                    VarName: str = Node.target.id

                    VarType: str = 'unknown'
                    IsPtr: bool = False
                    IsTypedef_assignment: bool = False

                    if Node.annotation:
                        try:
                            if AnnotationContainsName(Node.annotation, 'CTypedef'):
                                IsTypedef_assignment = True
                        except Exception as _e:
                            if _config_mode == "strict":
                                self.LogWarning(f"异常被忽略: {_e}")

                    if IsTypedef_assignment and Node.value:
                        if isinstance(Node.value, ast.Name):
                            OriginalType: str = Node.value.id
                            if OriginalType in self.GeneratedTypes:
                                OriginalInfo: CTypeInfo | None = self.SymbolTable.lookup(OriginalType)
                                if OriginalInfo:
                                    if isinstance(OriginalInfo, dict):
                                        actual_type: str = OriginalInfo.get('type', 'struct')
                                    elif isinstance(OriginalInfo, CTypeInfo):
                                        if OriginalInfo.IsEnum:
                                            actual_type = 'enum'
                                        elif OriginalInfo.IsTypedef:
                                            actual_type = 'typedef'
                                        elif OriginalInfo.IsStruct:
                                            actual_type = 'struct'
                                        else:
                                            actual_type = 'struct'
                                    else:
                                        actual_type = 'struct'
                                    if actual_type == 'enum':
                                        TypedefNode: CTypeInfo = CTypeInfo()
                                        TypedefNode.Name = VarName
                                        TypedefNode.IsTypedef = True
                                        TypedefNode.OriginalType = f'enum {OriginalType}'
                                        TypedefNode.file = '<stdin>'
                                        self.SymbolTable.insert(VarName, TypedefNode)
                                    elif actual_type == 'typedef':
                                        TypedefNode = CTypeInfo()
                                        TypedefNode.Name = VarName
                                        TypedefNode.IsTypedef = True
                                        if isinstance(OriginalInfo, dict):
                                            TypedefNode.OriginalType = OriginalInfo.get('OriginalType', f'struct {OriginalType}')
                                        elif isinstance(OriginalInfo, CTypeInfo) and OriginalInfo.OriginalType:
                                            TypedefNode.OriginalType = OriginalInfo.OriginalType
                                        else:
                                            TypedefNode.OriginalType = f'struct {OriginalType}'
                                        TypedefNode.file = '<stdin>'
                                        self.SymbolTable.insert(VarName, TypedefNode)
                                    else:
                                        TypedefNode = CTypeInfo()
                                        TypedefNode.Name = VarName
                                        TypedefNode.IsTypedef = True
                                        TypedefNode.OriginalType = f'struct {OriginalType}'
                                        TypedefNode.file = '<stdin>'
                                        self.SymbolTable.insert(VarName, TypedefNode)
                                    self.GeneratedTypes.add(VarName)
                                    continue
                            else:
                                OriginalInfo: CTypeInfo | None = self.SymbolTable.lookup(OriginalType)
                                if OriginalInfo:
                                    if isinstance(OriginalInfo, dict):
                                        actual_type: str = OriginalInfo.get('type', 'struct')
                                    elif isinstance(OriginalInfo, CTypeInfo):
                                        if OriginalInfo.IsEnum:
                                            actual_type = 'enum'
                                        elif OriginalInfo.IsTypedef:
                                            actual_type = 'typedef'
                                        elif OriginalInfo.IsStruct:
                                            actual_type = 'struct'
                                        else:
                                            actual_type = 'struct'
                                    else:
                                        actual_type = 'struct'
                                    if actual_type == 'typedef':
                                        TypedefNode: CTypeInfo = CTypeInfo()
                                        TypedefNode.Name = VarName
                                        TypedefNode.IsTypedef = True
                                        if isinstance(OriginalInfo, dict):
                                            TypedefNode.OriginalType = OriginalInfo.get('OriginalType', f'struct {OriginalType}')
                                        elif isinstance(OriginalInfo, CTypeInfo) and OriginalInfo.OriginalType:
                                            TypedefNode.OriginalType = OriginalInfo.OriginalType
                                        else:
                                            TypedefNode.OriginalType = f'struct {OriginalType}'
                                        TypedefNode.file = '<stdin>'
                                        self.SymbolTable.insert(VarName, TypedefNode)
                                        self.GeneratedTypes.add(VarName)
                                        if isinstance(OriginalInfo, dict):
                                            OriginalInfo['skip_generation'] = True
                                        continue
                                    elif actual_type == 'struct':
                                        TypedefNode = CTypeInfo()
                                        TypedefNode.Name = VarName
                                        TypedefNode.IsTypedef = True
                                        TypedefNode.OriginalType = f'struct {OriginalType}'
                                        TypedefNode.file = '<stdin>'
                                        self.SymbolTable.insert(VarName, TypedefNode)
                                        self.GeneratedTypes.add(VarName)
                                        if isinstance(OriginalInfo, dict):
                                            OriginalInfo['skip_generation'] = True
                                        continue
                                    elif actual_type == 'enum':
                                        TypedefNode = CTypeInfo()
                                        TypedefNode.Name = VarName
                                        TypedefNode.IsTypedef = True
                                        TypedefNode.OriginalType = f'enum {OriginalType}'
                                        TypedefNode.file = '<stdin>'
                                        self.SymbolTable.insert(VarName, TypedefNode)
                                        self.GeneratedTypes.add(VarName)
                                        if isinstance(OriginalInfo, dict):
                                            OriginalInfo['skip_generation'] = True
                                        continue
                        elif isinstance(Node.value, ast.Attribute):
                            CName: str | None = CTypeHelper.GetCName(Node.value.attr)
                            if CName:
                                TypedefNode: CTypeInfo = CTypeInfo()
                                TypedefNode.Name = VarName
                                TypedefNode.IsTypedef = True
                                TypedefNode.OriginalType = CName
                                TypedefNode.file = '<stdin>'
                                self.SymbolTable.insert(VarName, TypedefNode)
                                self.GeneratedTypes.add(VarName)
                                continue

                    if Node.annotation:
                        try:
                            TypeInfo: CTypeInfo | None = self.TypeMergeHandler.GetCTypeInfo(Node.annotation)
                            IsPtr = TypeInfo.IsPtr if TypeInfo else False
                        except Exception as _e:
                            if _config_mode == "strict":
                                self.LogWarning(f"异常被忽略: {_e}")
                    # 如果符号已经存在且是 typedef，不要覆盖它
                    existing = self.SymbolTable.lookup(VarName)
                    if existing and existing.IsTypedef and existing.OriginalType:
                        # typedef 已正确插入，保持现有条目不覆盖
                        pass
                    else:
                        var_node: CTypeInfo = CTypeInfo()
                        var_node.Name = VarName
                        var_node.IsVariable = True
                        var_node.PtrCount = 1 if IsPtr else 0
                        var_node.file = '<stdin>'
                        self.SymbolTable.insert(VarName, var_node)

        self.LlvmGen: LlvmCodeGenerator = LlvmCodeGenerator(
            triple=getattr(self, 'triple', None),
            datalayout=getattr(self, 'datalayout', None),
        )
        self.LlvmGen._Trans = self
        self.LlvmGen._import_handler_ref = self.ImportHandler
        if hasattr(self, '_module_sha1'):
            self.LlvmGen.module_sha1 = self._module_sha1
        if hasattr(self, '_ModuleSha1Map'):
            self.LlvmGen.ModuleSha1Map = self._ModuleSha1Map
        if hasattr(self, '_struct_sha1_map'):
            self.LlvmGen._struct_sha1_map = self._struct_sha1_map
        if hasattr(self, '_temp_dir'):
            self.LlvmGen._temp_dir = self._temp_dir
        if hasattr(self, '_export_extern_funcs'):
            self.LlvmGen._export_extern_funcs = self._export_extern_funcs
        self.LlvmGen.setup_from_symbol_table(self.SymbolTable)
        if hasattr(self, 'CurrentFile') and self.CurrentFile:
            self.LlvmGen._set_source_info(self.CurrentFile)

        # --- 修复：共享 vtable 状态跨模块 ---
        # 根因：LlvmGen 每模块重新创建，class_vtable/class_methods 等是实例级属性，
        # 不跨模块共享。导致模块 B 编译时 _specialize_generic_class 触发的
        # pool.alloc(48) 找不到 MemManager 的虚表状态，直接调用 stub 返回 NULL → 段错误。
        # 修复：将 vtable 状态存储在 Translator 对象上并赋值给每个新 Gen。
        if not hasattr(self, '_shared_class_vtable'):
            self._shared_class_vtable: set[str] = set()
            self._shared_cross_module_vtable: set[str] = set()
            self._shared_class_methods: dict[str, list[str]] = {}
            self._shared_cross_module_novtable: set[str] = set()
        # 合并 setup_from_symbol_table 创建的实例级 class_methods 到共享 dict
        # （仅添加新类，不覆盖已有方法列表）
        for _cls_name, _methods in self.LlvmGen.class_methods.items():
            if _cls_name not in self._shared_class_methods:
                self._shared_class_methods[_cls_name] = _methods
            else:
                for _m in _methods:
                    if _m not in self._shared_class_methods[_cls_name]:
                        self._shared_class_methods[_cls_name].append(_m)
        # 替换为共享状态
        self.LlvmGen.class_vtable = self._shared_class_vtable
        self.LlvmGen._cross_module_vtable_classes = self._shared_cross_module_vtable
        self.LlvmGen.class_methods = self._shared_class_methods
        self.LlvmGen._cross_module_novtable = self._shared_cross_module_novtable
        # --- 修复结束 ---

        return self.GenerateLlvmDirect(Tree)