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 || ctx.is_const {
+                    // Statics and consts 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/snapshots__transpile@compound_literals.c.snap

@@ -25,12 +25,13 @@ pub const CHAR_ARRAY: [core::ffi::c_char; 6] =
 #[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_array_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();