transpile: Extend lifetime of compound literals whose address is taken

Author: Rua

c2rust-transpile/src/translator/mod.rs

@@ -3562,7 +3562,9 @@ impl<'c> Translation<'c> {
                     CastKind::BitCast | CastKind::PointerToIntegral | CastKind::NoOp => {
                         ctx.decay_ref = DecayRef::Yes
                     }
-                    CastKind::FunctionToPointerDecay | CastKind::BuiltinFnToFnPtr => {
+                    CastKind::ArrayToPointerDecay
+                    | CastKind::FunctionToPointerDecay
+                    | CastKind::BuiltinFnToFnPtr => {
                         ctx.needs_address = true;
                     }
                     _ => {}
@@ -4070,7 +4072,41 @@ impl<'c> Translation<'c> {
 
             Paren(_, val) => self.convert_expr(ctx, val, override_ty),
 
-            CompoundLiteral(_, val) => self.convert_expr(ctx, val, override_ty),
+            CompoundLiteral(qty, val) => {
+                let val = self.convert_expr(ctx, val, override_ty)?;
+
+                if !ctx.needs_address() || ctx.is_static {
+                    // Statics have their intermediates' lifetimes extended.
+                    return Ok(val);
+                }
+
+                // C compound literals are lvalues, but equivalent Rust expressions generally are not.
+                // So if an address is needed, store it in an intermediate variable first.
+                let fresh_name = self.renamer.borrow_mut().fresh();
+                let fresh_ty = self.convert_type(override_ty.unwrap_or(qty).ctype)?;
+
+                val.and_then(|val| {
+                    let fresh_stmt = {
+                        let mutbl = if qty.qualifiers.is_const {
+                            Mutability::Immutable
+                        } else {
+                            Mutability::Mutable
+                        };
+
+                        let local = mk().local(
+                            mk().set_mutbl(mutbl).ident_pat(&fresh_name),
+                            Some(fresh_ty),
+                            Some(val),
+                        );
+                        mk().local_stmt(Box::new(local))
+                    };
+
+                    Ok(WithStmts::new(
+                        vec![fresh_stmt],
+                        mk().ident_expr(fresh_name),
+                    ))
+                })
+            }
 
             InitList(ty, ref ids, opt_union_field_id, _) => {
                 self.convert_init_list(ctx, ty, ids, opt_union_field_id)

c2rust-transpile/tests/snapshots/compound_literals.c

@@ -1,11 +1,22 @@
 int static_single_int = (int) { 42 };
 int *static_single_int_ptr = &((int) { 42 });
 int *static_int_array_ptr = (int[]) { 42, 9001 };
-//char *static_char_ptr = (char[]) { "hello" };
+// Currently generates broken Rust code, see
+// https://github.com/immunant/c2rust/issues/1410
+//char *static_char_array_ptr = (char[]) { "hello" };
+
+#define SINGLE_INT ((int) { 42 })
+#define INT_ARRAY ((int[]) { 42, 9001 })
+#define CHAR_ARRAY ((char[]) { "hello" })
 
 void local_compound_literals() {
     int single_int = (int) { 42 };
     int *single_int_ptr = &((int) { 42 });
     int *int_array_ptr = (int[]) { 42, 9001 };
-    char *char_ptr = (char[]) { "hello" };
+    char *char_array_ptr = (char[]) { "hello" };
+
+    int macro_single_int = SINGLE_INT;
+    int *macro_single_int_ptr = &SINGLE_INT;
+    int *macro_int_array_ptr = INT_ARRAY;
+    char *macro_char_array_ptr = CHAR_ARRAY;
 }

c2rust-transpile/tests/snapshots/snapshots__transpile@compound_literals.c.snap

@@ -18,13 +18,22 @@ pub static mut static_single_int_ptr: *mut core::ffi::c_int =
     &42 as *const core::ffi::c_int as *mut core::ffi::c_int;
 #[no_mangle]
 pub static mut static_int_array_ptr: *mut core::ffi::c_int = [42, 9001].as_ptr() as *mut _;
+pub const SINGLE_INT: core::ffi::c_int = 42 as core::ffi::c_int;
+pub const INT_ARRAY: [core::ffi::c_int; 2] = [42 as core::ffi::c_int, 9001 as core::ffi::c_int];
+pub const CHAR_ARRAY: [core::ffi::c_char; 6] =
+    unsafe { ::core::mem::transmute::<[u8; 6], [core::ffi::c_char; 6]>(*b"hello\0") };
 #[no_mangle]
 pub unsafe extern "C" fn local_compound_literals() {
     let mut single_int: core::ffi::c_int = 42 as core::ffi::c_int;
-    let mut single_int_ptr: *mut core::ffi::c_int =
-        &mut (42 as core::ffi::c_int) as *mut core::ffi::c_int;
-    let mut int_array_ptr: *mut core::ffi::c_int =
-        [42 as core::ffi::c_int, 9001 as core::ffi::c_int].as_mut_ptr();
-    let mut char_ptr: *mut core::ffi::c_char =
-        (::core::mem::transmute::<[u8; 6], [core::ffi::c_char; 6]>(*b"hello\0")).as_mut_ptr();
+    let mut fresh0: core::ffi::c_int = 42 as core::ffi::c_int;
+    let mut single_int_ptr: *mut core::ffi::c_int = &mut fresh0 as *mut core::ffi::c_int;
+    let mut fresh1: [core::ffi::c_int; 2] = [42 as core::ffi::c_int, 9001 as core::ffi::c_int];
+    let mut int_array_ptr: *mut core::ffi::c_int = fresh1.as_mut_ptr();
+    let mut fresh2: [core::ffi::c_char; 6] =
+        ::core::mem::transmute::<[u8; 6], [core::ffi::c_char; 6]>(*b"hello\0");
+    let mut char_array_ptr: *mut core::ffi::c_char = fresh2.as_mut_ptr();
+    let mut macro_single_int: core::ffi::c_int = SINGLE_INT;
+    let mut macro_single_int_ptr: *mut core::ffi::c_int = &mut SINGLE_INT as *mut core::ffi::c_int;
+    let mut macro_int_array_ptr: *mut core::ffi::c_int = INT_ARRAY.as_mut_ptr();
+    let mut macro_char_array_ptr: *mut core::ffi::c_char = CHAR_ARRAY.as_mut_ptr();
 }