Update tests

lucic71 · lucic71 · commit 4bdbaf57dcc0 · 2026-05-10T11:52:10.000+01:00
diff --git a/tests/benchmarks/out/unsafe/bfs.rs b/tests/benchmarks/out/unsafe/bfs.rs
@@ -36,12 +36,16 @@ impl Queue {
         return ((self.back) == (0_u64));
     }
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for Queue {}
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct GraphNode {
     pub vertex: u32,
     pub next: *mut GraphNode,
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for GraphNode {}
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct Graph {
@@ -60,6 +64,8 @@ impl Graph {
         })) as *mut GraphNode);
     }
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for Graph {}
 pub unsafe fn BFS_0(graph: *const Graph, mut start_vertex: u32) -> *mut u32 {
     let mut Q: Queue = Queue {
         elems: Box::leak(
diff --git a/tests/benchmarks/out/unsafe/bst.rs b/tests/benchmarks/out/unsafe/bst.rs
@@ -13,6 +13,8 @@ pub struct node_t {
     pub right: *mut node_t,
     pub value: i32,
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for node_t {}
 pub unsafe fn find_0(mut node: *mut node_t, mut value: i32) -> *mut node_t {
     if ((value) < ((*node).value)) && (!(((*node).left).is_null())) {
         return (unsafe {
diff --git a/tests/unit/out/unsafe/10_struct.rs b/tests/unit/out/unsafe/10_struct.rs
@@ -12,6 +12,8 @@ pub struct GraphNode {
     pub dst: u32,
     pub next: *mut GraphNode,
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for GraphNode {}
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct Graph {
@@ -30,6 +32,8 @@ impl Graph {
         })) as *mut GraphNode);
     }
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for Graph {}
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
diff --git a/tests/unit/out/unsafe/bst.rs b/tests/unit/out/unsafe/bst.rs
@@ -13,6 +13,8 @@ pub struct node_t {
     pub right: *mut node_t,
     pub value: i32,
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for node_t {}
 pub unsafe fn find_0(mut node: *mut node_t, mut value: i32) -> *mut node_t {
     if ((value) < ((*node).value)) && (!(((*node).left).is_null())) {
         return (unsafe {
diff --git a/tests/unit/out/unsafe/c_struct.rs b/tests/unit/out/unsafe/c_struct.rs
@@ -24,6 +24,8 @@ pub struct Node {
     pub value: i32,
     pub next: *mut Node,
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for Node {}
 #[derive(Clone, Copy, PartialEq, Debug, Default)]
 enum Color {
     #[default]
diff --git a/tests/unit/out/unsafe/clone_vs_move.rs b/tests/unit/out/unsafe/clone_vs_move.rs
@@ -31,6 +31,8 @@ impl Default for Foo {
         }
     }
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for Foo {}
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
diff --git a/tests/unit/out/unsafe/complex_function.rs b/tests/unit/out/unsafe/complex_function.rs
@@ -40,6 +40,8 @@ impl X3 {
         return self.v;
     }
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for X3 {}
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct X4 {
diff --git a/tests/unit/out/unsafe/default.rs b/tests/unit/out/unsafe/default.rs
@@ -26,6 +26,8 @@ impl Default for Pointers {
         }
     }
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for Pointers {}
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
diff --git a/tests/unit/out/unsafe/exprs.rs b/tests/unit/out/unsafe/exprs.rs
@@ -25,6 +25,8 @@ impl Y {
         return (&mut self.x as *mut X);
     }
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for Y {}
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
diff --git a/tests/unit/out/unsafe/fn_ptr_cast.rs b/tests/unit/out/unsafe/fn_ptr_cast.rs
@@ -49,6 +49,8 @@ pub unsafe fn test_double_cast_2() {
 pub struct Command {
     pub data: *mut ::libc::c_void,
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for Command {}
 pub unsafe fn test_void_ptr_to_fn_3() {
     let mut cmd: Command = <Command>::default();
     cmd.data = std::mem::transmute::<Option<unsafe fn(i32) -> i32>, *mut ::libc::c_void>(Some(
diff --git a/tests/unit/out/unsafe/fn_ptr_struct.rs b/tests/unit/out/unsafe/fn_ptr_struct.rs
@@ -20,6 +20,8 @@ impl Default for Handler {
         }
     }
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for Handler {}
 pub unsafe fn double_it_0(mut x: i32) -> i32 {
     return ((x) * (2));
 }
diff --git a/tests/unit/out/unsafe/fn_ptr_vtable.rs b/tests/unit/out/unsafe/fn_ptr_vtable.rs
@@ -22,6 +22,8 @@ impl Default for Vtable {
         }
     }
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for Vtable {}
 pub static mut storage: i32 = 0_i32;
 pub unsafe fn int_create_0(mut val: i32) -> *mut ::libc::c_void {
     storage = val;
diff --git a/tests/unit/out/unsafe/huffman.rs b/tests/unit/out/unsafe/huffman.rs
@@ -19,6 +19,8 @@ impl MinHeapNode {
         return ((self.left).is_null()) && ((self.right).is_null());
     }
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for MinHeapNode {}
 pub unsafe fn Swap_0(a: *mut MinHeapNode, b: *mut MinHeapNode) {
     let mut t: MinHeapNode = MinHeapNode {
         data: (*a).data,
diff --git a/tests/unit/out/unsafe/linked_list.rs b/tests/unit/out/unsafe/linked_list.rs
@@ -17,6 +17,8 @@ impl Node {
         self.next = next;
     }
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for Node {}
 pub unsafe fn Find_0(mut head: *mut Node, mut idx: i32) -> *mut Node {
     let mut curr: *mut Node = head;
     let mut i: i32 = 0;
diff --git a/tests/unit/out/unsafe/new_bst.rs b/tests/unit/out/unsafe/new_bst.rs
@@ -13,6 +13,8 @@ pub struct node_t {
     pub right: *mut node_t,
     pub value: i32,
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for node_t {}
 pub unsafe fn find_0(mut node: *mut node_t, mut value: i32) -> *mut node_t {
     if ((value) < ((*node).value)) && (!(((*node).left).is_null())) {
         return (unsafe {
diff --git a/tests/unit/out/unsafe/push_emplace_back.rs b/tests/unit/out/unsafe/push_emplace_back.rs
@@ -17,6 +17,8 @@ pub struct Writer {
     pub output: *mut Vec<Chunk>,
     pub chunk: Chunk,
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for Writer {}
 #[repr(C)]
 #[derive(Clone, Default)]
 pub struct JPEGData {
diff --git a/tests/unit/out/unsafe/random.rs b/tests/unit/out/unsafe/random.rs
@@ -50,6 +50,8 @@ impl Default for Pair {
         }
     }
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for Pair {}
 pub unsafe fn zero_0() -> i32 {
     return 0;
 }
diff --git a/tests/unit/out/unsafe/send_sync_in_statics.rs b/tests/unit/out/unsafe/send_sync_in_statics.rs
@@ -12,7 +12,7 @@ pub struct Entry {
     pub name: *const u8,
     pub p: *mut i32,
 }
-// SAFETY: preserves unsafe C semantics; thread-safety is the programmer's responsibility
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
 unsafe impl Sync for Entry {}
 pub static single_entry: Entry = Entry {
     name: b"alone\0".as_ptr(),
diff --git a/tests/unit/out/unsafe/union_field_alignment.rs b/tests/unit/out/unsafe/union_field_alignment.rs
@@ -17,12 +17,16 @@ impl Default for node_anon_0 {
         unsafe { std::mem::zeroed() }
     }
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for node_anon_0 {}
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct node {
     pub next: *mut node,
     pub x: node_anon_0,
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for node {}
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
diff --git a/tests/unit/out/unsafe/union_pointer_pun_address.rs b/tests/unit/out/unsafe/union_pointer_pun_address.rs
@@ -17,6 +17,8 @@ pub struct node_b {
     pub data: *mut ::libc::c_void,
     pub next: *mut node_b,
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for node_b {}
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
@@ -34,7 +36,9 @@ unsafe fn main_0() -> i32 {
         fn default() -> Self {
             unsafe { std::mem::zeroed() }
         }
-    };
+    }
+    // SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+    unsafe impl Sync for anon_0 {};
     let mut ptr: anon_0 = <anon_0>::default();
     ptr.to_a = (&mut a as *mut node_a);
     let mut out: *mut node_b = ptr.to_b;
diff --git a/tests/unit/out/unsafe/union_pointer_pun_writethrough.rs b/tests/unit/out/unsafe/union_pointer_pun_writethrough.rs
@@ -23,7 +23,9 @@ unsafe fn main_0() -> i32 {
         fn default() -> Self {
             unsafe { std::mem::zeroed() }
         }
-    };
+    }
+    // SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+    unsafe impl Sync for anon_0 {};
     let mut pp: anon_0 = <anon_0>::default();
     pp.as_signed = (&mut x as *mut i64);
     (*pp.as_unsigned) = 42_u64;
diff --git a/tests/unit/out/unsafe/union_tagged_many_arms.rs b/tests/unit/out/unsafe/union_tagged_many_arms.rs
@@ -41,6 +41,8 @@ impl Default for Slot_anon_0 {
         unsafe { std::mem::zeroed() }
     }
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for Slot_anon_0 {}
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct Slot {
diff --git a/tests/unit/out/unsafe/union_tagged_simple.rs b/tests/unit/out/unsafe/union_tagged_simple.rs
@@ -32,13 +32,17 @@ impl Default for Event_anon_0 {
         unsafe { std::mem::zeroed() }
     }
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for Event_anon_0 {}
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct Event {
     pub kind: Kind,
     pub handle: *mut ::libc::c_void,
     pub payload: Event_anon_0,
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for Event {}
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
diff --git a/tests/unit/out/unsafe/union_tagged_struct_arms.rs b/tests/unit/out/unsafe/union_tagged_struct_arms.rs
@@ -30,6 +30,8 @@ pub struct Branch_anon_0_anon_0 {
     pub count: i64,
     pub cursor: i64,
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for Branch_anon_0_anon_0 {}
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct Branch_anon_0_anon_1 {
diff --git a/tests/unit/out/unsafe/union_void_ptr_sized_deref.rs b/tests/unit/out/unsafe/union_void_ptr_sized_deref.rs
@@ -36,6 +36,8 @@ impl Default for Sink_anon_0 {
         unsafe { std::mem::zeroed() }
     }
 }
+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced
+unsafe impl Sync for Sink_anon_0 {}
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct Sink {

Original file line number	Diff line number	Diff line change
`@@ -36,12 +36,16 @@ impl Queue {`
`36`	`36`	`return ((self.back) == (0_u64));`
`37`	`37`	`}`
`38`	`38`	`}`
	`39`	`+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced`
	`40`	`+unsafe impl Sync for Queue {}`
`39`	`41`	`#[repr(C)]`
`40`	`42`	`#[derive(Copy, Clone, Default)]`
`41`	`43`	`pub struct GraphNode {`
`42`	`44`	`pub vertex: u32,`
`43`	`45`	`pub next: *mut GraphNode,`
`44`	`46`	`}`
	`47`	`+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced`
	`48`	`+unsafe impl Sync for GraphNode {}`
`45`	`49`	`#[repr(C)]`
`46`	`50`	`#[derive(Copy, Clone, Default)]`
`47`	`51`	`pub struct Graph {`
`@@ -60,6 +64,8 @@ impl Graph {`
`60`	`64`	`})) as *mut GraphNode);`
`61`	`65`	`}`
`62`	`66`	`}`
	`67`	`+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced`
	`68`	`+unsafe impl Sync for Graph {}`
`63`	`69`	`pub unsafe fn BFS_0(graph: const Graph, mut start_vertex: u32) -> mut u32 {`
`64`	`70`	`let mut Q: Queue = Queue {`
`65`	`71`	`elems: Box::leak(`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,8 @@ pub struct node_t {`
`13`	`13`	`pub right: *mut node_t,`
`14`	`14`	`pub value: i32,`
`15`	`15`	`}`
	`16`	`+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced`
	`17`	`+unsafe impl Sync for node_t {}`
`16`	`18`	`pub unsafe fn find_0(mut node: mut node_t, mut value: i32) -> mut node_t {`
`17`	`19`	`if ((value) < ((node).value)) && (!(((node).left).is_null())) {`
`18`	`20`	`return (unsafe {`
Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,8 @@ pub struct GraphNode {`
`12`	`12`	`pub dst: u32,`
`13`	`13`	`pub next: *mut GraphNode,`
`14`	`14`	`}`
	`15`	`+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced`
	`16`	`+unsafe impl Sync for GraphNode {}`
`15`	`17`	`#[repr(C)]`
`16`	`18`	`#[derive(Copy, Clone, Default)]`
`17`	`19`	`pub struct Graph {`
`@@ -30,6 +32,8 @@ impl Graph {`
`30`	`32`	`})) as *mut GraphNode);`
`31`	`33`	`}`
`32`	`34`	`}`
	`35`	`+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced`
	`36`	`+unsafe impl Sync for Graph {}`
`33`	`37`	`pub fn main() {`
`34`	`38`	`unsafe {`
`35`	`39`	`std::process::exit(main_0() as i32);`
Original file line number	Diff line number	Diff line change
`@@ -24,6 +24,8 @@ pub struct Node {`
`24`	`24`	`pub value: i32,`
`25`	`25`	`pub next: *mut Node,`
`26`	`26`	`}`
	`27`	`+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced`
	`28`	`+unsafe impl Sync for Node {}`
`27`	`29`	`#[derive(Clone, Copy, PartialEq, Debug, Default)]`
`28`	`30`	`enum Color {`
`29`	`31`	`#[default]`
Original file line number	Diff line number	Diff line change
`@@ -31,6 +31,8 @@ impl Default for Foo {`
`31`	`31`	`}`
`32`	`32`	`}`
`33`	`33`	`}`
	`34`	`+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced`
	`35`	`+unsafe impl Sync for Foo {}`
`34`	`36`	`pub fn main() {`
`35`	`37`	`unsafe {`
`36`	`38`	`std::process::exit(main_0() as i32);`
Original file line number	Diff line number	Diff line change
`@@ -40,6 +40,8 @@ impl X3 {`
`40`	`40`	`return self.v;`
`41`	`41`	`}`
`42`	`42`	`}`
	`43`	`+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced`
	`44`	`+unsafe impl Sync for X3 {}`
`43`	`45`	`#[repr(C)]`
`44`	`46`	`#[derive(Copy, Clone, Default)]`
`45`	`47`	`pub struct X4 {`
Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,8 @@ impl Default for Pointers {`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`	`}`
	`29`	`+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced`
	`30`	`+unsafe impl Sync for Pointers {}`
`29`	`31`	`pub fn main() {`
`30`	`32`	`unsafe {`
`31`	`33`	`std::process::exit(main_0() as i32);`
Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,8 @@ impl Y {`
`25`	`25`	`return (&mut self.x as *mut X);`
`26`	`26`	`}`
`27`	`27`	`}`
	`28`	`+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced`
	`29`	`+unsafe impl Sync for Y {}`
`28`	`30`	`pub fn main() {`
`29`	`31`	`unsafe {`
`30`	`32`	`std::process::exit(main_0() as i32);`
Original file line number	Diff line number	Diff line change
`@@ -49,6 +49,8 @@ pub unsafe fn test_double_cast_2() {`
`49`	`49`	`pub struct Command {`
`50`	`50`	`pub data: *mut ::libc::c_void,`
`51`	`51`	`}`
	`52`	`+// SAFETY: preserves unsafe C semantics; thread-safety is not enforced`
	`53`	`+unsafe impl Sync for Command {}`
`52`	`54`	`pub unsafe fn test_void_ptr_to_fn_3() {`
`53`	`55`	`let mut cmd: Command = <Command>::default();`
`54`	`56`	`cmd.data = std::mem::transmute::<Option<unsafe fn(i32) -> i32>, *mut ::libc::c_void>(Some(`