transpile: Extend lifetime of compound literals whose address is taken (#1407)

- Fixes #1217.

I've only looked at fixing it in function context, as it's not possible
to add statements to static initializers ("Expected no side-effects in
static initializer" panic). But I'm not sure if the issue exists for
statics anyway, because Rust is forced to extend the lifetime of the
temporary to static in such a context.

There is also an issue with how this line compiles in the snapshot test:
```c
char *static_char_ptr = (char[]) { "hello" };
```

It gets translated into an array in which the first element is the
translated string, and then five zero integer literals. That's clearly
broken and doesn't compile in Rust, so I commented out that line. Since
my fix doesn't change how statics are handled, I believe that's an
existing bug in c2rust that needs its own fix.

Author: kkysen

c2rust-transpile/src/translator/mod.rs

@@ -3559,7 +3559,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;
                     }
                     _ => {}
@@ -4067,7 +4069,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/compound_literals.c

@@ -0,0 +1,29 @@
+int static_single_int = (int) { 42 };
+int *static_single_int_ptr = &((int) { 42 });
+int *static_int_ptr_to_array = (int[]) { 42, 9001 };
+// Currently generates broken Rust code, see
+// https://github.com/immunant/c2rust/issues/1410
+//char *static_char_ptr_to_array = (char[]) { "hello" };
+int (*static_int_array_ptr)[2] = &(int[]) { 42, 9001 };
+// As above
+//char (*static_char_array_ptr)[6] = &(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_ptr_to_array = (int[]) { 42, 9001 };
+    char *char_ptr_to_array = (char[]) { "hello" };
+    int (*int_array_ptr)[2] = &(int[]) { 42, 9001 };
+    char (*char_array_ptr)[6] = &(char[]) { "hello" };
+
+    int macro_single_int = SINGLE_INT;
+    int *macro_single_int_ptr = &SINGLE_INT;
+    int *macro_int_ptr_to_array = INT_ARRAY;
+    char *macro_char_ptr_to_array = CHAR_ARRAY;
+    int (*macro_int_array_ptr)[2] = &INT_ARRAY;
+    char (*macro_char_array_ptr)[6] = &CHAR_ARRAY;
+}

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

@@ -0,0 +1,57 @@
+---
+source: c2rust-transpile/tests/snapshots.rs
+expression: cat tests/snapshots/compound_literals.rs
+input_file: c2rust-transpile/tests/snapshots/compound_literals.c
+---
+#![allow(
+    dead_code,
+    non_camel_case_types,
+    non_snake_case,
+    non_upper_case_globals,
+    unused_assignments,
+    unused_mut
+)]
+#[no_mangle]
+pub static mut static_single_int: ::core::ffi::c_int = 42;
+#[no_mangle]
+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_ptr_to_array: *mut ::core::ffi::c_int = [42, 9001].as_ptr() as *mut _;
+#[no_mangle]
+pub static mut static_int_array_ptr: *mut [::core::ffi::c_int; 2] =
+    &[42, 9001] as *const [::core::ffi::c_int; 2] as *mut [::core::ffi::c_int; 2];
+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 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_ptr_to_array: *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_ptr_to_array: *mut ::core::ffi::c_char = fresh2.as_mut_ptr();
+    let mut fresh3: [::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; 2] =
+        &mut fresh3 as *mut [::core::ffi::c_int; 2];
+    let mut fresh4: [::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; 6] =
+        &mut fresh4 as *mut [::core::ffi::c_char; 6];
+    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_ptr_to_array: *mut ::core::ffi::c_int = INT_ARRAY.as_mut_ptr();
+    let mut macro_char_ptr_to_array: *mut ::core::ffi::c_char = CHAR_ARRAY.as_mut_ptr();
+    let mut macro_int_array_ptr: *mut [::core::ffi::c_int; 2] =
+        &mut INT_ARRAY as *mut [::core::ffi::c_int; 2];
+    let mut macro_char_array_ptr: *mut [::core::ffi::c_char; 6] =
+        &mut CHAR_ARRAY as *mut [::core::ffi::c_char; 6];
+}