修正了种子编译器的错误

lib/core/Handles/HandlesAnnAssign.py

@@ -521,6 +521,11 @@ class AnnAssignHandle(BaseHandle):
             InitValue: ir.Value | None = None
             if Node.value:
                 InitValue = self.HandleExprLlvm(Node.value, VarType=VarType)
+                # 闭包变量追踪：当赋值右侧是返回闭包的函数调用时，记录变量为闭包类型
+                if isinstance(Node.value, ast.Call) and isinstance(Node.value.func, ast.Name):
+                    CalledName: str = Node.value.func.id
+                    if CalledName in Gen._closure_return_types:
+                        Gen._closure_var_types[VarName] = Gen._closure_return_types[CalledName]
             if VarName in Gen._reg_values:
                 del Gen._reg_values[VarName]
             if VarName in Gen.variables and Gen.variables[VarName] is not None:

lib/core/Handles/HandlesAssign.py

@@ -163,6 +163,11 @@ class AssignHandle(BaseHandle):
                     if type_info.get('type') == 'CArray':
                         var_type_for_list = type_info.get('full_type')
                 Value: ir.Value | None = self.HandleExprLlvm(Node.value, VarType=var_type_for_list)
+                # 闭包变量追踪：当赋值右侧是返回闭包的函数调用时，记录变量为闭包类型
+                if isinstance(Node.value, ast.Call) and isinstance(Node.value.func, ast.Name):
+                    CalledName: str = Node.value.func.id
+                    if CalledName in Gen._closure_return_types:
+                        Gen._closure_var_types[VarName] = Gen._closure_return_types[CalledName]
                 if not Value:
                     return
                 if isinstance(Value.type, ir.VoidType):

lib/core/Handles/HandlesExprCall.py

@@ -327,6 +327,52 @@ class ExprCallHandle(BaseHandle):
                         if ArgVal:
                             args.append(ArgVal)
                     return Gen.builder.call(fn_ptr, args, name=f"call_{FuncName}")
+                # 处理 t.CPtr (i8*) 函数指针调用
+                # 当函数被赋值给 t.CPtr 变量时，原始函数类型退化为 i8*
+                # 检查是否是闭包变量（通过 _closure_var_types 追踪）
+                if isinstance(closure_ptr.type, ir.PointerType) and isinstance(closure_ptr.type.pointee, ir.IntType) and closure_ptr.type.pointee.width == 8:
+                    ClosureInfo: tuple[ir.Type, list[ir.Type]] | None = Gen._closure_var_types.get(FuncName)
+                    if ClosureInfo is not None:
+                        # 闭包结构体解包：{i8* env, i8* fn} -> 加载 env 和 fn，构造正确函数签名
+                        FnRetType: ir.Type = ClosureInfo[0]
+                        NonlocalArgTypes: list[ir.Type] = ClosureInfo[1]
+                        I8PtrType: ir.PointerType = ir.IntType(8).as_pointer()
+                        ClosureStructType: ir.LiteralStructType = ir.LiteralStructType([I8PtrType, I8PtrType])
+                        ClosureStructPtr: ir.Value = Gen.builder.bitcast(closure_ptr, ir.PointerType(ClosureStructType), name=f"cast_closure_{FuncName}")
+                        # 加载 env（field 0）和 fn（field 1）
+                        EnvGep: ir.Value = Gen.builder.gep(ClosureStructPtr, [ir.Constant(ir.IntType(32), 0), ir.Constant(ir.IntType(32), 0)], name=f"env_gep_{FuncName}")
+                        EnvVal: ir.Value = Gen._load(EnvGep, name=f"env_{FuncName}")
+                        FnGep: ir.Value = Gen.builder.gep(ClosureStructPtr, [ir.Constant(ir.IntType(32), 0), ir.Constant(ir.IntType(32), 1)], name=f"fn_gep_{FuncName}")
+                        FnVal: ir.Value = Gen._load(FnGep, name=f"fn_{FuncName}")
+                        # 收集用户调用参数
+                        UserArgTypes: list[ir.Type] = []
+                        UserCallArgs: list[ir.Value] = []
+                        for arg in Node.args:
+                            ArgVal = self.HandleExprLlvm(arg)
+                            if ArgVal:
+                                UserCallArgs.append(ArgVal)
+                                UserArgTypes.append(ArgVal.type)
+                        # 构造完整函数类型：[nonlocal_types..., user_arg_types...]
+                        FullArgTypes: list[ir.Type] = list(NonlocalArgTypes) + UserArgTypes
+                        FullFnType: ir.FunctionType = ir.FunctionType(FnRetType, FullArgTypes)
+                        FullFnPtr: ir.Value = Gen.builder.bitcast(FnVal, ir.PointerType(FullFnType), name=f"cast_fn_{FuncName}")
+                        # 调用参数：env 对应 nonlocal 参数，bitcast 到正确类型
+                        CallArgs: list[ir.Value] = []
+                        if NonlocalArgTypes:
+                            CallArgs.append(Gen.builder.bitcast(EnvVal, NonlocalArgTypes[0], name=f"cast_env_{FuncName}"))
+                        CallArgs.extend(UserCallArgs)
+                        return Gen.builder.call(FullFnPtr, CallArgs, name=f"call_{FuncName}")
+                    # 普通函数指针调用（无闭包）：从调用参数构造函数类型，默认返回 i32
+                    cptr_arg_types: list[ir.Type] = []
+                    cptr_call_args: list[ir.Value] = []
+                    for arg in Node.args:
+                        ArgVal = self.HandleExprLlvm(arg)
+                        if ArgVal:
+                            cptr_call_args.append(ArgVal)
+                            cptr_arg_types.append(ArgVal.type)
+                    cptr_fn_type = ir.FunctionType(ir.IntType(32), cptr_arg_types)
+                    cptr_fn_ptr = Gen.builder.bitcast(closure_ptr, ir.PointerType(cptr_fn_type), name=f"cast_fn_{FuncName}")
+                    return Gen.builder.call(cptr_fn_ptr, cptr_call_args, name=f"call_{FuncName}")
                 if isinstance(closure_ptr.type, ir.PointerType) and isinstance(closure_ptr.type.pointee, ir.LiteralStructType):
                     st = closure_ptr.type.pointee
                     if len(st.elements) == 2 and isinstance(st.elements[1], ir.PointerType) and isinstance(st.elements[1].pointee, ir.FunctionType):
@@ -352,11 +398,16 @@ class ExprCallHandle(BaseHandle):
             raise Exception(f"Undefined function: '{FuncName}'")
         if isinstance(Node.func, ast.Subscript):
             # Handle list[int](mb) syntax — generic class constructor with explicit type args
+            # Handle xxx[T](x) syntax — generic function call with explicit type args
             sub: ast.Subscript = Node.func
             if isinstance(sub.value, ast.Name):
-                ClassName: str = sub.value.id
-                if hasattr(self.Trans.ClassHandler, '_generic_class_templates') and ClassName in self.Trans.ClassHandler._generic_class_templates:
-                    return self._HandleGenericClassNewLlvm(Node, ClassName, explicit_slice=sub.slice)
+                FuncName: str = sub.value.id
+                # 优先检查泛型类模板
+                if hasattr(self.Trans.ClassHandler, '_generic_class_templates') and FuncName in self.Trans.ClassHandler._generic_class_templates:
+                    return self._HandleGenericClassNewLlvm(Node, FuncName, explicit_slice=sub.slice)
+                # 检查泛型函数模板（如 xxx[T](x)）
+                if hasattr(self.Trans.FunctionHandler, '_generic_templates') and FuncName in self.Trans.FunctionHandler._generic_templates:
+                    return self._HandleGenericCallExplicitLlvm(Node, FuncName, explicit_slice=sub.slice)
         if isinstance(Node.func, ast.Attribute):
             if Node.func.attr in ('update', 'final', 'transform'):
                 pass
@@ -489,6 +540,42 @@ class ExprCallHandle(BaseHandle):
                 if (is_instance_var or _is_chained_instance) and not is_class_name:
                     return self._HandleMethodCallLlvm(Node)
                 FuncAttr = Node.func.attr
+                # c 模块的特殊语法设施（Addr/Deref/DerefAs/Set/Load/Asm 等）必须优先处理，
+                # 即使它们在 Gen.structs 中（c.py 的类会被声明为结构体但不应被实例化）。
+                # c.py 是语法部分，不应被编译，其中的类是编译器语法设施。
+                # 必须在 Gen.structs 检查之前处理，否则 c.Deref/c.DerefAs 会被
+                # _HandleClassNewLlvm 当成普通类实例化（根因：HandlesExprCall.py:497）。
+                if ModulePath == 'c':
+                    if FuncAttr == 'Asm':
+                        return self.Trans.ExprAsmHandle._HandleAsmLlvm(Node)
+                    elif FuncAttr == 'Addr':
+                        return self.Trans.CSpecialCallHandle._HandleCAddrLlvm(Node)
+                    elif FuncAttr == 'Set':
+                        return self.Trans.CSpecialCallHandle._HandleCSetLlvm(Node)
+                    elif FuncAttr == 'Load':
+                        return self.Trans.CSpecialCallHandle._HandleCLoadLlvm(Node)
+                    elif FuncAttr == 'Deref':
+                        return self.Trans.CSpecialCallHandle._HandleCDerefLlvm(Node)
+                    elif FuncAttr == 'DerefAs':
+                        return self._HandleCDerefAsLlvm(Node)
+                    elif FuncAttr == 'PtrToInt':
+                        return self.Trans.CSpecialCallHandle._HandleCPtrToIntLlvm(Node)
+                    elif FuncAttr in ('CIf', 'CElif'):
+                        return self.Trans.CSpecialCallHandle._HandleCIfLlvm(Node)
+                    elif FuncAttr == 'CError':
+                        msg = "compile-time error"
+                        if Node.args:
+                            arg = Node.args[0]
+                            if isinstance(arg, ast.Constant) and isinstance(arg.value, str):
+                                msg = arg.value
+                        lineno = getattr(Node, 'lineno', 0)
+                        raise Exception(f"#error: {msg} (line {lineno})")
+                    elif FuncAttr in ('AsmInp', 'AsmOut'):
+                        return ir.Constant(ir.IntType(32), 0)
+                    elif FuncAttr == 'LLVMIR':
+                        return self._HandleLLVMIRLlvm(Node)
+                    elif FuncAttr in ('LInp', 'LOut'):
+                        return ir.Constant(ir.IntType(32), 0)
                 if FuncAttr in Gen.structs:
                     result = self._HandleClassNewLlvm(Node, FuncAttr, module_sha1=_ctor_module_sha1)
                     if result is not None:
@@ -572,40 +659,6 @@ class ExprCallHandle(BaseHandle):
                             result = self._HandleClassNewLlvm(Node, FuncAttr, module_sha1=_ctor_module_sha1)
                             if result is not None:
                                 return result
-                # c 模块的特殊语法设施（Addr/Deref/DerefAs/Set/Load/Asm 等）必须优先处理，
-                # 即使它们在 Gen.structs 中（c.py 的类会被声明为结构体但不应被实例化）。
-                # c.py 是语法部分，不应被编译，其中的类是编译器语法设施。
-                if ModulePath == 'c':
-                    if FuncAttr == 'Asm':
-                        return self.Trans.ExprAsmHandle._HandleAsmLlvm(Node)
-                    elif FuncAttr == 'Addr':
-                        return self.Trans.CSpecialCallHandle._HandleCAddrLlvm(Node)
-                    elif FuncAttr == 'Set':
-                        return self.Trans.CSpecialCallHandle._HandleCSetLlvm(Node)
-                    elif FuncAttr == 'Load':
-                        return self.Trans.CSpecialCallHandle._HandleCLoadLlvm(Node)
-                    elif FuncAttr == 'Deref':
-                        return self.Trans.CSpecialCallHandle._HandleCDerefLlvm(Node)
-                    elif FuncAttr == 'DerefAs':
-                        return self._HandleCDerefAsLlvm(Node)
-                    elif FuncAttr == 'PtrToInt':
-                        return self.Trans.CSpecialCallHandle._HandleCPtrToIntLlvm(Node)
-                    elif FuncAttr in ('CIf', 'CElif'):
-                        return self.Trans.CSpecialCallHandle._HandleCIfLlvm(Node)
-                    elif FuncAttr == 'CError':
-                        msg = "compile-time error"
-                        if Node.args:
-                            arg = Node.args[0]
-                            if isinstance(arg, ast.Constant) and isinstance(arg.value, str):
-                                msg = arg.value
-                        lineno = getattr(Node, 'lineno', 0)
-                        raise Exception(f"#error: {msg} (line {lineno})")
-                    elif FuncAttr in ('AsmInp', 'AsmOut'):
-                        return ir.Constant(ir.IntType(32), 0)
-                    elif FuncAttr == 'LLVMIR':
-                        return self._HandleLLVMIRLlvm(Node)
-                    elif FuncAttr in ('LInp', 'LOut'):
-                        return ir.Constant(ir.IntType(32), 0)
                 if FuncAttr in Gen.structs:
                     result = self._HandleClassNewLlvm(Node, FuncAttr, module_sha1=_ctor_module_sha1)
                     if result is not None:
@@ -1037,21 +1090,55 @@ class ExprCallHandle(BaseHandle):
 
         icmp_match = re.match(r'icmp\s+(\w+)\s+(\w+)\s+%__OP(\d+)__,\s*%__OP(\d+)__', template)
         if icmp_match:
-            pred = icmp_match.group(1)
+            pred: str = icmp_match.group(1)
             op1 = resolve_op(int(icmp_match.group(3)))
             op2 = resolve_op(int(icmp_match.group(4)))
             if op1 and op2:
-                result = Gen.builder.icmp_signed(pred, op1, op2, name="llvmir_result")
-                return self._StoreLLVMIROutputs(Gen, result, output_targets)
+                # LLVM IR 谓词（eq/ne/sgt/sge/slt/sle/ugt/uge/ult/ule）映射到 llvmlite
+                # llvmlite 的 icmp_signed/icmp_unsigned 只接受 '=='/'!='/'<'/'<='/'>'/>='
+                _ICMP_PRED_MAP: dict[str, tuple[str, str]] = {
+                    'eq': ('==', 'signed'), 'ne': ('!=', 'signed'),
+                    'sgt': ('>', 'signed'), 'sge': ('>=', 'signed'),
+                    'slt': ('<', 'signed'), 'sle': ('<=', 'signed'),
+                    'ugt': ('>', 'unsigned'), 'uge': ('>=', 'unsigned'),
+                    'ult': ('<', 'unsigned'), 'ule': ('<=', 'unsigned'),
+                }
+                pred_info: tuple[str, str] | None = _ICMP_PRED_MAP.get(pred)
+                if pred_info:
+                    llvmlite_pred: str
+                    cmp_kind: str
+                    llvmlite_pred, cmp_kind = pred_info
+                    icmp_method: Any = Gen.builder.icmp_signed if cmp_kind == 'signed' else Gen.builder.icmp_unsigned
+                    result = icmp_method(llvmlite_pred, op1, op2, name="llvmir_result")
+                    return self._StoreLLVMIROutputs(Gen, result, output_targets)
 
-        fcmp_match = re.match(r'fcmp\s+(\w+(?:\s+fast)?)\s+(\w+)\s+%__OP(\d+)__,\s*%__OP(\d+)__', template)
+        fcmp_match = re.match(r'fcmp\s+([\w\s]+?)\s+(\w+)\s+%__OP(\d+)__,\s*%__OP(\d+)__', template)
         if fcmp_match:
-            pred = fcmp_match.group(1)
+            pred_raw: str = fcmp_match.group(1).strip()
+            # 分离 fast 修饰符（可能是 "oeq fast" 或 "fast oeq"）
+            is_fast: bool = 'fast' in pred_raw
+            pred: str = pred_raw.replace('fast', '').strip()
             op1 = resolve_op(int(fcmp_match.group(3)))
             op2 = resolve_op(int(fcmp_match.group(4)))
             if op1 and op2:
-                result = Gen.builder.fcmp_ordered(pred, op1, op2, name="llvmir_result")
-                return self._StoreLLVMIROutputs(Gen, result, output_targets)
+                # LLVM IR fcmp 谓词（oeq/ogt/olt/ord/uno/ueq 等）映射到 llvmlite
+                _FCMP_PRED_MAP: dict[str, tuple[str, str]] = {
+                    'oeq': ('==', 'ordered'), 'ogt': ('>', 'ordered'),
+                    'oge': ('>=', 'ordered'), 'olt': ('<', 'ordered'),
+                    'ole': ('<=', 'ordered'), 'one': ('!=', 'ordered'),
+                    'ord': ('ord', 'ordered'), 'uno': ('uno', 'unordered'),
+                    'ueq': ('==', 'unordered'), 'ugt': ('>', 'unordered'),
+                    'uge': ('>=', 'unordered'), 'ult': ('<', 'unordered'),
+                    'ule': ('<=', 'unordered'), 'une': ('!=', 'unordered'),
+                }
+                fcmp_info: tuple[str, str] | None = _FCMP_PRED_MAP.get(pred)
+                if fcmp_info:
+                    llvmlite_pred: str
+                    cmp_kind: str
+                    llvmlite_pred, cmp_kind = fcmp_info
+                    fcmp_method: Any = Gen.builder.fcmp_ordered if cmp_kind == 'ordered' else Gen.builder.fcmp_unordered
+                    result = fcmp_method(llvmlite_pred, op1, op2, name="llvmir_result")
+                    return self._StoreLLVMIROutputs(Gen, result, output_targets)
 
         for op_name, method_name in binop_map.items():
             pattern = re.compile(
@@ -3547,6 +3634,10 @@ class ExprCallHandle(BaseHandle):
 
     def _HandleClassNewLlvm(self, Node: ast.Call, ClassName: str, module_sha1: str | None = None) -> ir.Value:
         Gen: LlvmGeneratorMixin = self.Trans.LlvmGen
+        # DEBUG: 追踪 Asm 类的构造
+        if ClassName == 'Asm':
+            import sys as _dbg_sys
+            print(f"[DEBUG_CLASSNEW] _HandleClassNewLlvm called for Asm, module_sha1={module_sha1}", file=_dbg_sys.stderr)
         # 跨模块类型引用：优先用 {module_sha1}.{ClassName} 查找 struct
         _struct_full_key: str | None = f"{module_sha1}.{ClassName}" if module_sha1 else None
 
@@ -3562,6 +3653,9 @@ class ExprCallHandle(BaseHandle):
         InitFuncName = f'{ClassName}.__init__'
         NewMethodFuncName = f'{ClassName}.__new__'
         has_new_method = Gen._find_function(NewMethodFuncName) is not None
+        if ClassName == 'Asm':
+            import sys as _dbg_sys
+            print(f"[DEBUG_CLASSNEW] Asm: has_before_init={Gen._has_function(NewFuncName)}, has_new={has_new_method}, struct_in_gen={ClassName in Gen.structs}", file=_dbg_sys.stderr)
         if Gen._has_function(NewFuncName):
             NewFunc = Gen._get_function(NewFuncName)
             StructType = _get_struct_type(ClassName)
@@ -3873,6 +3967,59 @@ class ExprCallHandle(BaseHandle):
             return ElemPtr
         return None
 
+    def _HandleGenericCallExplicitLlvm(self, Node: ast.Call, FuncName: str, explicit_slice: ast.AST) -> ir.Value | None:
+        """处理泛型函数手动传类型参数的调用 xxx[T](x)。
+
+        与自动推导的 _HandleGenericCallLlvm 不同，这里从 explicit_slice
+        提取类型参数，而不是从参数值推导。
+        """
+        Gen: LlvmGeneratorMixin = self.Trans.LlvmGen
+        template: dict = self.Trans.FunctionHandler._generic_templates[FuncName]
+        type_param_names: list[str] = template['type_params']
+        # 从 slice 提取类型参数
+        type_args: list[str] = []
+        slice_nodes: list[ast.AST] = []
+        if isinstance(explicit_slice, ast.Tuple):
+            slice_nodes = list(explicit_slice.elts)
+        else:
+            slice_nodes = [explicit_slice]
+        for sn in slice_nodes:
+            result = self._resolve_generic_slice_type(sn)
+            if result is not None:
+                type_args.append(result[0])
+        # 补齐缺少的类型参数
+        while len(type_args) < len(type_param_names):
+            type_args.append('int')
+        type_args = type_args[:len(type_param_names)]
+        # 特化
+        spec_name = self.Trans.FunctionHandler._specialize_generic_function(FuncName, type_args, Gen)
+        if spec_name is None:
+            return None
+        mangled_spec = Gen._mangle_func_name(spec_name)
+        func = None
+        if mangled_spec in Gen.functions:
+            func = Gen.functions[mangled_spec]
+        elif spec_name in Gen.functions:
+            func = Gen.functions[spec_name]
+        else:
+            for fname, fobj in Gen.functions.items():
+                if spec_name in fname or fname.endswith(spec_name):
+                    func = fobj
+                    break
+        if func is None:
+            return None
+        # 处理调用参数
+        CallArgs: list[ir.Value] = []
+        for arg_node in Node.args:
+            arg_val = self.HandleExprLlvm(arg_node)
+            if arg_val:
+                CallArgs.append(arg_val)
+        if not CallArgs:
+            CallArgs = [ir.Constant(ir.IntType(32), 0) for _ in func.args]
+        CallArgs = Gen._apply_auto_addr(spec_name, CallArgs)
+        adjusted = Gen._adjust_args(CallArgs, func)
+        return Gen.builder.call(func, adjusted, name=f"call_{spec_name}")
+
     def _HandleGenericCallLlvm(self, Node: ast.Call, FuncName: str) -> ir.Value | None:
         Gen: LlvmGeneratorMixin = self.Trans.LlvmGen
         template: dict = self.Trans.FunctionHandler._generic_templates[FuncName]

lib/core/Handles/HandlesExprOps.py

@@ -21,10 +21,12 @@ class ExprOpsHandle(BaseHandle):
         Op: str | None = self.Trans.ExprHandler.GetOpSymbol(Node.op)
         if not Op:
             return None
-        OP_OVERLOAD_MAP: dict[str, str] = {
-            '+': '__add__', '-': '__sub__', '*': '__mul__',
-            '/': '__truediv__', '//': '__floordiv__', '%': '__mod__',
-            '**': '__pow__',
+        OP_OVERLOAD_MAP: dict[str, list[str]] = {
+            '+': ['__add__'], '-': ['__sub__'], '*': ['__mul__'],
+            '/': ['__truediv__', '__div__'], '//': ['__floordiv__'], '%': ['__mod__'],
+            '**': ['__pow__'],
+            '&': ['__and__'], '|': ['__or__'], '^': ['__xor__'],
+            '<<': ['__lshift__'], '>>': ['__rshift__'],
         }
         if Op in OP_OVERLOAD_MAP:
             LeftClassName: str | None = None
@@ -47,10 +49,11 @@ class ExprOpsHandle(BaseHandle):
                         TargetStructPtr = ir.PointerType(Gen.structs[LeftClassName])
                         LeftVal = Gen.builder.bitcast(LeftVal, TargetStructPtr, name=f"bitcast_to_{LeftClassName}")
             if LeftClassName:
-                op_name: str = OP_OVERLOAD_MAP[Op]
-                result: Any = self.Trans.ExprUtils._try_operator_overLoad(LeftClassName, op_name, LeftVal, Gen, RightVal)
-                if result is not None:
-                    return result
+                op_names: list[str] = OP_OVERLOAD_MAP[Op]
+                for op_name in op_names:
+                    result: Any = self.Trans.ExprUtils._try_operator_overLoad(LeftClassName, op_name, LeftVal, Gen, RightVal)
+                    if result is not None:
+                        return result
         if Op in ('+', 'Add') and isinstance(LeftVal.type, ir.PointerType) and isinstance(RightVal.type, ir.IntType):
             if isinstance(LeftVal.type.pointee, ir.IntType) and LeftVal.type.pointee.width == 8:
                 if isinstance(Node.left, ast.Constant) and isinstance(Node.left.value, str) and len(Node.left.value) == 1:
@@ -282,6 +285,36 @@ class ExprOpsHandle(BaseHandle):
             RightVal: Any = self.HandleExprLlvm(Node.comparators[0])
             if not RightVal:
                 return None
+            # 比较运算符重载检测：当左侧是结构体指针时，尝试调用 __eq__/__ne__/__lt__/__le__/__gt__/__ge__
+            CMP_OVERLOAD_MAP: dict[str, str] = {
+                '==': '__eq__', '!=': '__ne__', '<': '__lt__',
+                '<=': '__le__', '>': '__gt__', '>=': '__ge__',
+            }
+            if ComparatorSymbol in CMP_OVERLOAD_MAP:
+                LeftClassName: str | None = None
+                if isinstance(LeftVal.type, ir.PointerType):
+                    pointee: ir.Type = LeftVal.type.pointee
+                    if isinstance(pointee, (ir.IdentifiedStructType, ir.LiteralStructType)):
+                        for CN, ST in Gen.structs.items():
+                            if pointee == ST:
+                                LeftClassName = CN
+                                break
+                    elif isinstance(pointee, ir.IntType) and pointee.width == 8:
+                        LeftClassName = self.Trans.ExprUtils._get_var_class(Node.left, Gen)
+                        if LeftClassName and LeftClassName in Gen.structs:
+                            TargetStructPtr: ir.PointerType = ir.PointerType(Gen.structs[LeftClassName])
+                            LeftVal = Gen.builder.bitcast(LeftVal, TargetStructPtr, name=f"bitcast_to_{LeftClassName}")
+                if LeftClassName is None and isinstance(Node.left, ast.Name):
+                    LeftClassName = Gen.var_struct_class.get(Node.left.id)
+                    if LeftClassName and LeftClassName in Gen.structs:
+                        if isinstance(LeftVal.type, ir.PointerType) and isinstance(LeftVal.type.pointee, ir.IntType) and LeftVal.type.pointee.width == 8:
+                            TargetStructPtr = ir.PointerType(Gen.structs[LeftClassName])
+                            LeftVal = Gen.builder.bitcast(LeftVal, TargetStructPtr, name=f"bitcast_to_{LeftClassName}")
+                if LeftClassName:
+                    op_name: str = CMP_OVERLOAD_MAP[ComparatorSymbol]
+                    result: Any = self.Trans.ExprUtils._try_operator_overLoad(LeftClassName, op_name, LeftVal, Gen, RightVal)
+                    if result is not None:
+                        return result
             if isinstance(LeftVal, ir.Constant) and isinstance(RightVal, ir.Constant):
                 if isinstance(LeftVal.type, ir.IntType) and isinstance(RightVal.type, ir.IntType):
                     lv: int = LeftVal.constant

lib/core/Handles/HandlesFor.py

@@ -330,6 +330,33 @@ class ForHandle(BaseHandle):
         for name in implicit_names:
             if name not in nonlocal_var_names:
                 nonlocal_var_names.append(name)
+        # 堆分配 nonlocal 变量：避免外层函数返回后栈帧释放导致悬垂指针
+        # 闭包返回模式（return nested_fn）要求捕获变量在堆上存活
+        malloc_fn_type: ir.FunctionType = ir.FunctionType(ir.IntType(8).as_pointer(), [ir.IntType(64)])
+        malloc_func: ir.Function = Gen._get_or_declare_func('malloc', malloc_fn_type)
+        for var_name in nonlocal_var_names:
+            if var_name in Gen.variables and Gen.variables[var_name] is not None:
+                old_var: ir.Value = Gen.variables[var_name]
+                if isinstance(old_var.type, ir.PointerType):
+                    elem_type: ir.Type = old_var.type.pointee
+                    # 计算元素大小（字节）
+                    elem_size: int = 8  # 默认指针大小
+                    if isinstance(elem_type, ir.IntType):
+                        elem_size = max(1, elem_type.width // 8)
+                    elif isinstance(elem_type, ir.FloatType):
+                        elem_size = 4
+                    elif isinstance(elem_type, ir.DoubleType):
+                        elem_size = 8
+                    elif isinstance(elem_type, ir.PointerType):
+                        elem_size = 8
+                    # malloc 堆存储
+                    heap_raw: ir.Value = Gen.builder.call(malloc_func, [ir.Constant(ir.IntType(64), elem_size)], name=f"heap_{var_name}")
+                    heap_ptr: ir.Value = Gen.builder.bitcast(heap_raw, ir.PointerType(elem_type), name=f"heap_{var_name}_ptr")
+                    # 复制栈值到堆
+                    old_val: ir.Value = Gen._load(old_var, name=f"load_old_{var_name}")
+                    Gen._store(old_val, heap_ptr)
+                    # 更新 Gen.variables 使外层和嵌套函数都使用堆指针
+                    Gen.variables[var_name] = heap_ptr
         extra_params: list[tuple[str, ir.Type]] = []
         for var_name in nonlocal_var_names:
             if var_name in Gen.variables and Gen.variables[var_name] is not None:

lib/core/Handles/HandlesFunctions.py

@@ -652,7 +652,17 @@ class FunctionHandle(BaseHandle):
                         ParamTypeInfo.ArrayDims = []
                         ParamTypeInfo.PtrCount = max(ParamTypeInfo.PtrCount, 1)
                     ParamType: ir.Type = Gen._ctype_to_llvm(ParamTypeInfo)
+                    # 参数类型不能是 VoidType：C 语言不允许 void 参数，
+                    # VoidType 说明类型注解无法识别（如跨模块 ast.expr），直接报错终止
+                    if isinstance(ParamType, ir.VoidType):
+                        AnnStr: str = ast.unparse(Arg.annotation) if hasattr(ast, 'unparse') else str(Arg.annotation)
+                        raise SyntaxError(
+                            f"无法识别的参数类型注解: '{AnnStr}'（在函数 '{Node.name}' 的参数 '{Arg.arg}' 上）。"
+                            f"请使用有效的 TPV 类型（如 t.CPtr、ast.AST 或已注册的结构体）。"
+                        )
                     ParamTypeStr: Any = ParamTypeInfo
+                except SyntaxError:
+                    raise
                 except Exception as e:
                     ParamType = ir.IntType(32)
                     ParamTypeStr = CTypeInfo()
@@ -1402,9 +1412,19 @@ class FunctionHandle(BaseHandle):
                         ParamTypeInfo.ArrayDims = []
                         ParamTypeInfo.PtrCount = max(ParamTypeInfo.PtrCount, 1)
                     ParamType = Gen._ctype_to_llvm(ParamTypeInfo)
+                    # 参数类型不能是 VoidType：C 语言不允许 void 参数，
+                    # VoidType 说明类型注解无法识别（如跨模块 ast.expr），直接报错终止
+                    if isinstance(ParamType, ir.VoidType):
+                        AnnStr: str = ast.unparse(Arg.annotation) if hasattr(ast, 'unparse') else str(Arg.annotation)
+                        raise SyntaxError(
+                            f"无法识别的参数类型注解: '{AnnStr}'（在函数 '{Node.name}' 的参数 '{Arg.arg}' 上）。"
+                            f"请使用有效的 TPV 类型（如 t.CPtr、ast.AST 或已注册的结构体）。"
+                        )
                     if ParamTypeInfo and ParamTypeInfo.IsFuncPtr:
                         ParamType = ir.IntType(8).as_pointer()
                     ParamIsUnsigned = ParamTypeInfo.IsUInt
+                except SyntaxError:
+                    raise
                 except Exception:  # 回退：参数类型解析失败时使用默认 i32
                     ParamType = ir.IntType(32)
                     ParamTypeInfo = CTypeInfo()

lib/core/Handles/HandlesImports.py

@@ -1323,8 +1323,12 @@ class ImportHandle(BaseHandle):
 
     def _EmitExternalClassDeclLlvm(self, Node: ast.ClassDef, Gen: LlvmGeneratorMixin, module_name: str | None = None, actual_module_name: str | None = None, source_sha1: str | None = None) -> None:
         ClassName = Node.name
-        if hasattr(Node, 'type_params') and Node.type_params:
-            return
+        # PEP 695 泛型类（如 GSListNode[T]）不再完全跳过：跨模块继承展平需要从泛型基类
+        # 获取字段（如 Next），否则子类（如 Value(GSListNode[Value])）的 class_members
+        # 会缺少继承字段，导致 struct body 字段数不正确 → GEP 索引错位 → 崩溃。
+        # 但泛型类的方法声明必须跳过：方法参数类型 T 会被解析为 opaque struct，
+        # LLVM 不允许 opaque struct 作为值参数（invalid type for function argument）。
+        IsGenericClass: bool = hasattr(Node, 'type_params') and bool(Node.type_params)
         IsCenum = False
         IsRenum = False
         IsCpythonObject = False
@@ -1579,19 +1583,23 @@ class ImportHandle(BaseHandle):
         # 此时 MemManager 尚未注册到虚表，导致直接调用返回 NULL → 段错误。
         # 修复：在 _TryLoadStructFromStub 之前预扫描方法列表并提前注册虚表。
         _has_methods_prescan = False
-        for _item in Node.body:
-            if isinstance(_item, ast.FunctionDef):
-                _has_methods_prescan = True
-                _MethodName = _item.name
-                # 构造函数（__new__/__init__/__before_init__）不放入 vtable，
-                # 避免子类与基类 vtable 大小不一致导致虚分派索引偏移
-                # （如 Module 有 __new__/__init__ 使 vtable=7，AST 无它们 vtable=5，
-                # 调用方按 AST 布局取 append@idx4 实际取到 Module.dump@idx4）。
-                if _MethodName in ('__new__', '__init__', '__before_init__'):
-                    continue
-                _FuncFullName = f"{ClassName}.__init__" if _MethodName == "__init__" else f"{ClassName}.__call__" if _MethodName == "__call__" else f"{ClassName}.{_MethodName}"
-                if _FuncFullName not in Gen.class_methods[ClassName]:
-                    Gen.class_methods[ClassName].append(_FuncFullName)
+        # PEP 695 泛型类的方法声明必须跳过：方法参数类型 T（如 list[T].append(item: T)）
+        # 会被解析为 opaque struct，LLVM 报 "invalid type for function argument"。
+        # 字段（AnnAssign）仍正常加载，确保继承字段（如 GSListNode.Next）可被展平。
+        if not IsGenericClass:
+            for _item in Node.body:
+                if isinstance(_item, ast.FunctionDef):
+                    _has_methods_prescan = True
+                    _MethodName = _item.name
+                    # 构造函数（__new__/__init__/__before_init__）不放入 vtable，
+                    # 避免子类与基类 vtable 大小不一致导致虚分派索引偏移
+                    # （如 Module 有 __new__/__init__ 使 vtable=7，AST 无它们 vtable=5，
+                    # 调用方按 AST 布局取 append@idx4 实际取到 Module.dump@idx4）。
+                    if _MethodName in ('__new__', '__init__', '__before_init__'):
+                        continue
+                    _FuncFullName = f"{ClassName}.__init__" if _MethodName == "__init__" else f"{ClassName}.__call__" if _MethodName == "__call__" else f"{ClassName}.{_MethodName}"
+                    if _FuncFullName not in Gen.class_methods[ClassName]:
+                        Gen.class_methods[ClassName].append(_FuncFullName)
         if _has_methods_prescan and IsCVTable:
             Gen._cross_module_vtable_classes.add(ClassName)
             Gen.class_vtable.add(ClassName)
@@ -1651,7 +1659,10 @@ class ImportHandle(BaseHandle):
                         const = self._BuildScalarConstant(item.value, MemberType, Gen)
                         if const:
                             Gen.class_member_defaults[ClassName][VarName] = const
-            elif isinstance(item, ast.FunctionDef):
+            elif isinstance(item, ast.FunctionDef) and not IsGenericClass:
+                # PEP 695 泛型类跳过方法声明：T 参数会变成 opaque struct 触发
+                # "invalid type for function argument"。字段已由上面的 AnnAssign
+                # 分支加载，继承字段（如 GSListNode.Next）由后面的展平逻辑补充。
                 has_methods = True
                 MethodName = item.name
                 FuncFullName = f"{ClassName}.__init__" if MethodName == "__init__" else f"{ClassName}.__call__" if MethodName == "__call__" else f"{ClassName}.{MethodName}"

lib/core/Handles/HandlesReturn.py

@@ -16,6 +16,58 @@ class ReturnHandle(BaseHandle):
 
     def _HandleReturnLlvm(self, Node: ast.Return) -> None:
         Gen: "Translator.LlvmGen" = self.Trans.LlvmGen
+        # 闭包返回检测：当返回值是带 nonlocal 参数的嵌套函数时，创建闭包结构体
+        # 闭包结构体 {i8* env, i8* fn} 在堆上分配，env 指向 nonlocal 变量的堆存储
+        if Node.value and isinstance(Node.value, ast.Name):
+            ret_name: str = Node.value.id
+            if ret_name in Gen.nonlocal_params and ret_name in Gen.functions:
+                nested_fn: ir.Function = Gen.functions[ret_name]
+                nonlocal_params: list[tuple[str, ir.Type]] = Gen.nonlocal_params[ret_name]
+                fn_return_type: ir.Type = nested_fn.function_type.return_type
+                nonlocal_types: list[ir.Type] = [t for _, t in nonlocal_params]
+                # 构建 env：收集所有 nonlocal 变量指针
+                env_ptrs: list[ir.Value] = []
+                for var_name, _ in nonlocal_params:
+                    vp: ir.Value | None = Gen.variables.get(var_name)
+                    if vp is not None:
+                        env_ptrs.append(vp)
+                if env_ptrs:
+                    # env 值：单个指针直接用，多个指针打包成结构体
+                    i8_ptr_type: ir.PointerType = ir.IntType(8).as_pointer()
+                    if len(env_ptrs) == 1:
+                        env_val: ir.Value = Gen.builder.bitcast(env_ptrs[0], i8_ptr_type, name="closure_env")
+                    else:
+                        env_struct_type: ir.LiteralStructType = ir.LiteralStructType([p.type for p in env_ptrs])
+                        env_size: int = len(env_ptrs) * 8
+                        malloc_type: ir.FunctionType = ir.FunctionType(i8_ptr_type, [ir.IntType(64)])
+                        malloc_func: ir.Function = Gen._get_or_declare_func('malloc', malloc_type)
+                        env_raw: ir.Value = Gen.builder.call(malloc_func, [ir.Constant(ir.IntType(64), env_size)], name="env_struct_raw")
+                        env_struct_ptr: ir.Value = Gen.builder.bitcast(env_raw, ir.PointerType(env_struct_type), name="env_struct_ptr")
+                        for i, ptr in enumerate(env_ptrs):
+                            gep: ir.Value = Gen.builder.gep(env_struct_ptr, [ir.Constant(ir.IntType(32), 0), ir.Constant(ir.IntType(32), i)], name=f"env_field_{i}")
+                            Gen._store(ptr, gep)
+                        env_val = Gen.builder.bitcast(env_struct_ptr, i8_ptr_type, name="closure_env")
+                    # fn 指针
+                    fn_ptr: ir.Value = Gen.builder.bitcast(nested_fn, i8_ptr_type, name="closure_fn")
+                    # 创建闭包结构体 {i8* env, i8* fn}
+                    closure_type: ir.LiteralStructType = ir.LiteralStructType([i8_ptr_type, i8_ptr_type])
+                    malloc_type2: ir.FunctionType = ir.FunctionType(i8_ptr_type, [ir.IntType(64)])
+                    malloc_func2: ir.Function = Gen._get_or_declare_func('malloc', malloc_type2)
+                    closure_raw: ir.Value = Gen.builder.call(malloc_func2, [ir.Constant(ir.IntType(64), 16)], name="closure_raw")
+                    closure_ptr: ir.Value = Gen.builder.bitcast(closure_raw, ir.PointerType(closure_type), name="closure_ptr")
+                    # 填充闭包结构体
+                    env_gep: ir.Value = Gen.builder.gep(closure_ptr, [ir.Constant(ir.IntType(32), 0), ir.Constant(ir.IntType(32), 0)], name="closure_env_slot")
+                    Gen._store(env_val, env_gep)
+                    fn_gep: ir.Value = Gen.builder.gep(closure_ptr, [ir.Constant(ir.IntType(32), 0), ir.Constant(ir.IntType(32), 1)], name="closure_fn_slot")
+                    Gen._store(fn_ptr, fn_gep)
+                    # 记录闭包返回类型
+                    current_name: str = Gen.func.name if Gen.func else ''
+                    short_name: str = current_name.split('.', 1)[1] if '.' in current_name else current_name
+                    Gen._closure_return_types[short_name] = (fn_return_type, nonlocal_types)
+                    # 返回闭包结构体指针（bitcast 到 i8*）
+                    closure_ret: ir.Value = Gen.builder.bitcast(closure_ptr, i8_ptr_type, name="closure_ret")
+                    Gen.emit_return(closure_ret)
+                    return
         active_finally: tuple[ir.Block, ir.AllocaInstr, ir.AllocaInstr | None] | None = self._find_active_finally(Gen)
         if getattr(self.Trans, 'CurrentCReturnTypes', None) and self.Trans.CurrentCReturnTypes and Node.value:
             return_values: list[ast.expr] = []