transpile: add cleanup attribute test

Author: thedataking

tests/unit/cleanup_attr/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "cleanup-attr-tests"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

tests/unit/cleanup_attr/build.rs

@@ -0,0 +1,7 @@
+use std::env;
+
+fn main() {
+    let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
+
+    println!("cargo:rustc-link-search=native={}", manifest_dir);
+}

tests/unit/cleanup_attr/src/cleanup.c

@@ -0,0 +1,109 @@
+static int trace_buf[16];
+static int trace_n;
+
+static void reset(void) {
+    trace_n = 0;
+}
+
+static void copy_trace(int *out, int *n) {
+    int i;
+    for (i = 0; i < trace_n; i++) out[i] = trace_buf[i];
+    *n = trace_n;
+}
+
+static void record(int *p) {
+    if (trace_n < 16) trace_buf[trace_n++] = *p;
+}
+
+/* Each `do_*` helper runs the cleanup-bearing code in its own function so
+ * that all cleanups complete on return; the outer `run_*` then copies the
+ * recorded trace. This matters because c2rust flattens nested C blocks
+ * into the enclosing function scope, so `cleanup` doesn't fire at the
+ * end of a `{ ... }` block, only at function return. */
+
+static void do_single(void) {
+    int x __attribute__((cleanup(record))) = 5;
+    (void)x;
+}
+
+void run_single(int *out, int *n) {
+    reset();
+    do_single();
+    copy_trace(out, n);
+}
+
+static void do_multiple(void) {
+    int a __attribute__((cleanup(record))) = 1;
+    int b __attribute__((cleanup(record))) = 2;
+    int c __attribute__((cleanup(record))) = 3;
+    (void)a; (void)b; (void)c;
+}
+
+void run_multiple(int *out, int *n) {
+    reset();
+    do_multiple();
+    copy_trace(out, n);
+}
+
+static void do_early_return(void) {
+    int x __attribute__((cleanup(record))) = 7;
+    (void)x;
+    return;
+}
+
+void run_early_return(int *out, int *n) {
+    reset();
+    do_early_return();
+    copy_trace(out, n);
+}
+
+static void do_nested(void) {
+    int outer __attribute__((cleanup(record))) = 10;
+    {
+        int inner __attribute__((cleanup(record))) = 20;
+        (void)inner;
+    }
+    (void)outer;
+}
+
+void run_nested(int *out, int *n) {
+    reset();
+    do_nested();
+    copy_trace(out, n);
+}
+
+/* Back-edge via goto forces c2rust to hoist locals. The cleanup variable
+ * is naturally reached, but its declaration sits in a hoisted block, so
+ * this verifies the guard runs on the assignment site rather than on the
+ * bare zero-init at function top. */
+static void do_goto(void) {
+    int counter __attribute__((cleanup(record))) = 0;
+again:
+    counter++;
+    if (counter < 3) goto again;
+}
+
+void run_goto(int *out, int *n) {
+    reset();
+    do_goto();
+    copy_trace(out, n);
+}
+
+typedef struct {
+    int v;
+} widget_t;
+
+static void widget_destroy(widget_t *w) {
+    record(&w->v);
+}
+
+static void do_typedef(void) {
+    widget_t w __attribute__((cleanup(widget_destroy))) = { 42 };
+    (void)w;
+}
+
+void run_typedef(int *out, int *n) {
+    reset();
+    do_typedef();
+    copy_trace(out, n);
+}

tests/unit/cleanup_attr/src/test_cleanup.rs

@@ -0,0 +1,61 @@
+use crate::cleanup::{
+    rust_run_early_return, rust_run_goto, rust_run_multiple, rust_run_nested, rust_run_single,
+    rust_run_typedef,
+};
+use std::ffi::c_int;
+
+#[link(name = "test")]
+unsafe extern "C" {
+    fn run_single(out: *mut c_int, n: *mut c_int);
+    fn run_multiple(out: *mut c_int, n: *mut c_int);
+    fn run_early_return(out: *mut c_int, n: *mut c_int);
+    fn run_nested(out: *mut c_int, n: *mut c_int);
+    fn run_goto(out: *mut c_int, n: *mut c_int);
+    fn run_typedef(out: *mut c_int, n: *mut c_int);
+}
+
+type EntryFn = unsafe extern "C" fn(out: *mut c_int, n: *mut c_int);
+
+fn collect(entry: EntryFn) -> Vec<c_int> {
+    let mut buf = [0i32; 16];
+    let mut n: c_int = 0;
+    unsafe { entry(buf.as_mut_ptr(), &mut n) };
+    buf[..n as usize].to_vec()
+}
+
+fn check(c_entry: EntryFn, rust_entry: EntryFn, expected: &[c_int]) {
+    let c_trace = collect(c_entry);
+    let rust_trace = collect(rust_entry);
+    assert_eq!(c_trace, expected, "C side diverged from expected");
+    assert_eq!(rust_trace, expected, "Rust side diverged from expected");
+}
+
+#[test]
+pub fn test_single() {
+    check(run_single, rust_run_single, &[5]);
+}
+
+#[test]
+pub fn test_reverse_declaration_order() {
+    check(run_multiple, rust_run_multiple, &[3, 2, 1]);
+}
+
+#[test]
+pub fn test_fires_through_early_return() {
+    check(run_early_return, rust_run_early_return, &[7]);
+}
+
+#[test]
+pub fn test_nested_block() {
+    check(run_nested, rust_run_nested, &[20, 10]);
+}
+
+#[test]
+pub fn test_goto_with_hoisted_local() {
+    check(run_goto, rust_run_goto, &[3]);
+}
+
+#[test]
+pub fn test_typedef_signature() {
+    check(run_typedef, rust_run_typedef, &[42]);
+}