Use temporary variable for addr-of compound literal

Author: Rua

c2rust-transpile/src/translator/operators.rs

@@ -927,8 +927,10 @@ impl<'c> Translation<'c> {
                 let arg = self.convert_expr(ctx.used().set_needs_address(true), arg, None)?;
 
                 if self.ast_context.is_function_pointer(ctype) {
-                    Ok(arg.map(|x| mk().call_expr(mk().ident_expr("Some"), vec![x])))
-                } else {
+                    return Ok(arg.map(|x| mk().call_expr(mk().ident_expr("Some"), vec![x])));
+                }
+
+                arg.and_then(|mut val| {
                     let pointee_ty =
                         self.ast_context
                             .get_pointee_qual_type(ctype)
@@ -941,21 +943,33 @@ impl<'c> Translation<'c> {
                     } else {
                         Mutability::Mutable
                     };
+                    let mut stmts = vec![];
+
+                    // If we're taking the address of a compound literal, which is a temporary,
+                    // store the argument in a variable first, then take its address.
+                    if let CExprKind::CompoundLiteral(..) = arg_kind {
+                        let arg_name = self.renamer.borrow_mut().fresh();
+                        stmts.push(mk().local_stmt(Box::new(mk().local(
+                            mk().set_mutbl(mutbl).ident_pat(&arg_name),
+                            None,
+                            Some(val),
+                        ))));
+                        val = mk().ident_expr(arg_name);
+                    }
 
-                    Ok(arg.map(|a| {
-                        self.use_feature("raw_ref_op");
+                    self.use_feature("raw_ref_op");
+                    if ctx.is_static && matches!(mutbl, Mutability::Mutable) {
+                        // TODO: The currently used nightly doesn't allow `&raw mut` in static
+                        // initialisers, but the latest version does.
+                        // So we take a `&raw const` and then cast.
+                        // Remove this exemption when the version is updated.
+                        val = mk().cast_expr(mk().raw_borrow_expr(val), ty);
+                    } else {
+                        val = mk().set_mutbl(mutbl).raw_borrow_expr(val);
+                    }
 
-                        if ctx.is_static && matches!(mutbl, Mutability::Mutable) {
-                            // TODO: The currently used nightly doesn't allow `&raw mut` in static
-                            // initialisers, but the latest version does.
-                            // So we take a `&raw const` and then cast.
-                            // Remove this exemption when the version is updated.
-                            mk().cast_expr(mk().raw_borrow_expr(a), ty)
-                        } else {
-                            mk().set_mutbl(mutbl).raw_borrow_expr(a)
-                        }
-                    }))
-                }
+                    Ok(WithStmts::new(stmts, val))
+                })
             }
             c_ast::UnOp::PreIncrement => self.convert_pre_increment(ctx, cqual_type, true, arg),
             c_ast::UnOp::PreDecrement => self.convert_pre_increment(ctx, cqual_type, false, arg),