修正了种子编译器的错误

lib/Projectrans/DeclarationGenerator.py

@@ -110,8 +110,9 @@ class DeclarationGenerator:
                 if decl:
                     lines.append(decl)
             elif isinstance(node, ast.ClassDef):
-                if hasattr(node, 'type_params') and node.type_params:
-                    continue
+                # PEP 695 泛型类不再完全跳过：子类（如 Value(GSListNode[Value])）的
+                # 继承字段展平需要从泛型基类的 stub 中读取字段（如 GSListNode.Next）。
+                # _generate_class_decl 内部会跳过泛型类的方法声明（T 参数 → opaque struct）。
                 decls: list[str] = self._generate_class_decl(node)
                 lines.extend(decls)
 
@@ -625,37 +626,42 @@ class DeclarationGenerator:
             else:
                 new_func_decl = f'declare void @{new_func_name}({struct_type_name}*)'
             decls.append(new_func_decl)
-        for item in node.body:
-            if isinstance(item, ast.FunctionDef):
-                if hasattr(item, 'type_params') and item.type_params:
-                    continue
-                method_name: str = f'{class_name}.{item.name}'
-                if self.module_sha1:
-                    method_name = f"{self.module_sha1}.{method_name}"
-                ret_type: str = self._get_type_str(item.returns) if item.returns else 'void'
-                if not ret_type:
-                    ret_type = 'void'
-                params: list[str] = []
-                for arg_idx, arg in enumerate(item.args.args):
-                    arg_type: str
-                    if arg.annotation:
-                        arg_type = self._get_type_str(arg.annotation)
-                    elif arg_idx == 0 and arg.arg == 'self':
-                        arg_type = f'{struct_type_name}*'
+        # PEP 695 泛型类跳过方法声明生成：方法参数类型 T 会被解析为 opaque struct，
+        # LLVM 报 "invalid type for function argument"。字段（AnnAssign）仍正常生成，
+        # 确保子类（如 Value(GSListNode[Value])）能从 stub 中读取继承字段（如 Next）。
+        IsGenericClass: bool = hasattr(node, 'type_params') and bool(node.type_params)
+        if not IsGenericClass:
+            for item in node.body:
+                if isinstance(item, ast.FunctionDef):
+                    if hasattr(item, 'type_params') and item.type_params:
+                        continue
+                    method_name: str = f'{class_name}.{item.name}'
+                    if self.module_sha1:
+                        method_name = f"{self.module_sha1}.{method_name}"
+                    ret_type: str = self._get_type_str(item.returns) if item.returns else 'void'
+                    if not ret_type:
+                        ret_type = 'void'
+                    params: list[str] = []
+                    for arg_idx, arg in enumerate(item.args.args):
+                        arg_type: str
+                        if arg.annotation:
+                            arg_type = self._get_type_str(arg.annotation)
+                        elif arg_idx == 0 and arg.arg == 'self':
+                            arg_type = f'{struct_type_name}*'
+                        else:
+                            arg_type = 'i8*'
+                        # C 语言中数组参数退化为指针：[N x elem_type] → elem_type*
+                        arg_type = self._decay_array_to_ptr(arg_type)
+                        params.append(arg_type)
+                    param_str: str = ', '.join(params) if params else ''
+                    if method_name[0].isdigit():
+                        decls.append(f'declare {ret_type} @"{method_name}"({param_str})')
                     else:
-                        arg_type = 'i8*'
-                    # C 语言中数组参数退化为指针：[N x elem_type] → elem_type*
-                    arg_type = self._decay_array_to_ptr(arg_type)
-                    params.append(arg_type)
-                param_str: str = ', '.join(params) if params else ''
-                if method_name[0].isdigit():
-                    decls.append(f'declare {ret_type} @"{method_name}"({param_str})')
-                else:
-                    decls.append(f'declare {ret_type} @{method_name}({param_str})')
-        # 为继承但未覆写的方法生成包装声明
-        # 这些声明让跨模块调用能正确解析子类包装函数的签名，
-        # 避免 stub 缺失导致默认 i32 返回类型 → 64 位指针截断
-        decls.extend(self._generate_inherited_method_decls(node, class_name, struct_type_name))
+                        decls.append(f'declare {ret_type} @{method_name}({param_str})')
+            # 为继承但未覆写的方法生成包装声明
+            # 这些声明让跨模块调用能正确解析子类包装函数的签名，
+            # 避免 stub 缺失导致默认 i32 返回类型 → 64 位指针截断
+            decls.extend(self._generate_inherited_method_decls(node, class_name, struct_type_name))
         return decls
 
     def _generate_inherited_method_decls(self, node: ast.ClassDef, child_class_name: str, child_struct_type: str) -> list[str]: