Reapply fixes

Author: Rua

c2rust-transpile/src/rust_ast/set_span.rs

@@ -140,6 +140,7 @@ impl SetSpan for Expr {
                 RangeLimits::Closed(mut r) => r.spans[0] = s,
                 RangeLimits::HalfOpen(mut r) => r.spans[0] = s,
             },
+            Expr::RawAddr(e) => e.and_token.span = s,
             Expr::Reference(e) => e.and_token.span = s,
             Expr::Return(e) => e.return_token.span = s,
             Expr::Try(e) => e.question_token.span = s,

c2rust-transpile/src/translator/mod.rs

@@ -4510,22 +4510,36 @@ impl<'c> Translation<'c> {
                     _ => {
                         // Variable length arrays are already represented as pointers.
                         if let CTypeKind::VariableArray(..) = source_ty_kind {
-                            Ok(val)
+                            return Ok(val);
+                        }
+
+                        let mutbl = if is_const {
+                            Mutability::Immutable
                         } else {
-                            let mutbl = if is_const {
-                                Mutability::Immutable
+                            Mutability::Mutable
+                        };
+
+                        let target_element_ty = self.convert_type(target_cty.ctype)?;
+
+                        Ok(val.map(|mut val| {
+                            self.use_feature("raw_ref_op");
+
+                            // TODO: The currently used nightly doesn't allow `&raw mut` in
+                            // static initialisers, but it's allowed since version 1.83.
+                            // So we take a `&raw const` and then cast.
+                            // Remove this exemption when the version is updated.
+                            if ctx.is_static && matches!(mutbl, Mutability::Mutable) {
+                                val = mk().raw_borrow_expr(val);
                             } else {
-                                Mutability::Mutable
-                            };
-                            let target_ty = self.convert_type(target_cty.ctype)?;
-
-                            Ok(val.map(|x| {
-                                self.use_feature("raw_ref_op");
-                                let borrow = mk().set_mutbl(mutbl).raw_borrow_expr(x);
-                                // TODO: Change to call `ptr::as_[mut]_ptr` once that is available.
-                                mk().cast_expr(borrow, target_ty)
-                            }))
-                        }
+                                val = mk().set_mutbl(mutbl).raw_borrow_expr(val);
+                            }
+
+                            // Cast to element type.
+                            // TODO: Change to call `ptr::as_[mut]_ptr` once that is available,
+                            // and cast only if `source_ty_kind.element_ty() != pointee.ctype`
+                            // (`array_ptr_get` feature added to nightly in January 2024)
+                            mk().cast_expr(val, target_element_ty)
+                        }))
                     }
                 }
             }

c2rust-transpile/src/translator/operators.rs

@@ -901,6 +901,7 @@ impl<'c> Translation<'c> {
         lrvalue: LRValue,
     ) -> TranslationResult<WithStmts<Box<Expr>>> {
         let CQualTypeId { ctype, .. } = cqual_type;
+        let ty = self.convert_type(ctype)?;
         let resolved_ctype = self.ast_context.resolve_type(ctype);
 
         let mut unary = match name {
@@ -923,27 +924,54 @@ impl<'c> Translation<'c> {
                 // In this translation, there are only pointers to functions and
                 // & becomes a no-op when applied to a function.
 
-                let arg = self.convert_expr(ctx.used().set_needs_address(true), arg, None)?;
+                let val = 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])))
+                    return Ok(val.map(|x| mk().call_expr(mk().ident_expr("Some"), vec![x])));
+                }
+
+                let pointee_ty =
+                    self.ast_context
+                        .get_pointee_qual_type(ctype)
+                        .ok_or_else(|| {
+                            TranslationError::generic("Address-of should return a pointer")
+                        })?;
+
+                let mutbl = if pointee_ty.qualifiers.is_const {
+                    Mutability::Immutable
                 } else {
-                    let pointee_ty =
-                        self.ast_context
-                            .get_pointee_qual_type(ctype)
-                            .ok_or_else(|| {
-                                TranslationError::generic("Address-of should return a pointer")
-                            })?;
-
-                    let mutbl = if pointee_ty.qualifiers.is_const {
-                        Mutability::Immutable
+                    Mutability::Mutable
+                };
+
+                Ok(val.map(|mut val| {
+                    if matches!(
+                        arg_kind,
+                        CExprKind::Literal(..) | CExprKind::CompoundLiteral(..)
+                    ) {
+                        // Rust does not extend the lifetime of temporaries with a raw borrow,
+                        // but will do so with a regular borrow.
+                        val = mk().set_mutbl(mutbl).borrow_expr(val);
+
+                        if ctx.decay_ref.is_yes() {
+                            val = mk().cast_expr(val, ty)
+                        }
                     } else {
-                        Mutability::Mutable
-                    };
+                        self.use_feature("raw_ref_op");
+
+                        // TODO: The currently used nightly doesn't allow `&raw mut` in
+                        // static initialisers, but it's allowed since version 1.83.
+                        // So we take a `&raw const` and then cast.
+                        // Remove this exemption when the version is updated.
+                        if ctx.is_static && matches!(mutbl, Mutability::Mutable) {
+                            val = mk().raw_borrow_expr(val);
+                            val = mk().cast_expr(val, ty);
+                        } else {
+                            val = mk().set_mutbl(mutbl).raw_borrow_expr(val);
+                        }
+                    }
 
-                    self.use_feature("raw_ref_op");
-                    Ok(arg.map(|a| mk().set_mutbl(mutbl).raw_borrow_expr(a)))
-                }
+                    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),

c2rust-transpile/tests/snapshots/[email protected]

@@ -12,6 +12,7 @@ input_file: c2rust-transpile/tests/snapshots/arrays.c
     unused_assignments,
     unused_mut
 )]
+#![feature(raw_ref_op)]
 #[derive(Copy, Clone)]
 #[repr(C)]
 pub struct C2RustUnnamed {
@@ -79,11 +80,9 @@ pub unsafe extern "C" fn entry() {
         &[u8; 20],
         &mut [std::ffi::c_char; 20],
     >(b"abc\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0");
-    let mut past_end: *mut std::ffi::c_char = &mut *simple
-        .as_mut_ptr()
-        .offset(::core::mem::size_of::<[std::ffi::c_char; 9]>() as isize)
-        as *mut std::ffi::c_char;
-    past_end = &mut *foo.offset(8 as std::ffi::c_int as isize) as *mut std::ffi::c_char;
+    let mut past_end: *mut std::ffi::c_char = &raw mut *(&raw mut simple as *mut std::ffi::c_char)
+        .offset(::core::mem::size_of::<[std::ffi::c_char; 9]>() as isize);
+    past_end = &raw mut *foo.offset(8 as std::ffi::c_int as isize);
 }
 #[no_mangle]
 pub unsafe extern "C" fn short_initializer() {

c2rust-transpile/tests/snapshots/[email protected]

@@ -12,28 +12,29 @@ input_file: c2rust-transpile/tests/snapshots/atomics.c
     unused_assignments,
     unused_mut
 )]
-#![feature(core_intrinsics)]
+#![feature(core_intrinsics, raw_ref_op)]
 #[no_mangle]
 pub unsafe extern "C" fn c11_atomics(mut x: std::ffi::c_int) -> std::ffi::c_int {
-    *&mut x = 0 as std::ffi::c_int;
-    ::core::intrinsics::atomic_store_seqcst(&mut x, 1 as std::ffi::c_int);
-    ::core::intrinsics::atomic_load_seqcst(&mut x);
-    ::core::intrinsics::atomic_xadd_seqcst(&mut x, 2 as std::ffi::c_int);
-    ::core::intrinsics::atomic_xsub_seqcst(&mut x, 1 as std::ffi::c_int);
-    ::core::intrinsics::atomic_and_seqcst(&mut x, 0xf as std::ffi::c_int);
-    ::core::intrinsics::atomic_or_seqcst(&mut x, 0x10 as std::ffi::c_int);
-    ::core::intrinsics::atomic_nand_seqcst(&mut x, 0xff as std::ffi::c_int);
-    ::core::intrinsics::atomic_xchg_seqcst(&mut x, 42 as std::ffi::c_int);
+    *&raw mut x = 0 as std::ffi::c_int;
+    ::core::intrinsics::atomic_store_seqcst(&raw mut x, 1 as std::ffi::c_int);
+    ::core::intrinsics::atomic_load_seqcst(&raw mut x);
+    ::core::intrinsics::atomic_xadd_seqcst(&raw mut x, 2 as std::ffi::c_int);
+    ::core::intrinsics::atomic_xsub_seqcst(&raw mut x, 1 as std::ffi::c_int);
+    ::core::intrinsics::atomic_and_seqcst(&raw mut x, 0xf as std::ffi::c_int);
+    ::core::intrinsics::atomic_or_seqcst(&raw mut x, 0x10 as std::ffi::c_int);
+    ::core::intrinsics::atomic_nand_seqcst(&raw mut x, 0xff as std::ffi::c_int);
+    ::core::intrinsics::atomic_xchg_seqcst(&raw mut x, 42 as std::ffi::c_int);
     let mut expected: std::ffi::c_int = 42 as std::ffi::c_int;
     let mut desired: std::ffi::c_int = 100 as std::ffi::c_int;
-    let fresh0 = ::core::intrinsics::atomic_cxchg_seqcst_seqcst(&mut x, *&mut expected, desired);
-    *&mut expected = fresh0.0;
+    let fresh0 =
+        ::core::intrinsics::atomic_cxchg_seqcst_seqcst(&raw mut x, *&raw mut expected, desired);
+    *&raw mut expected = fresh0.0;
     fresh0.1;
     expected = 100 as std::ffi::c_int;
     desired = 200 as std::ffi::c_int;
     let fresh1 =
-        ::core::intrinsics::atomic_cxchgweak_seqcst_seqcst(&mut x, *&mut expected, desired);
-    *&mut expected = fresh1.0;
+        ::core::intrinsics::atomic_cxchgweak_seqcst_seqcst(&raw mut x, *&raw mut expected, desired);
+    *&raw mut expected = fresh1.0;
     fresh1.1;
     return x;
 }

c2rust-transpile/tests/snapshots/[email protected]

@@ -12,6 +12,7 @@ input_file: c2rust-transpile/tests/snapshots/exprs.c
     unused_assignments,
     unused_mut
 )]
+#![feature(raw_ref_op)]
 extern "C" {
     fn puts(str: *const std::ffi::c_char) -> std::ffi::c_int;
 }
@@ -30,7 +31,7 @@ pub unsafe extern "C" fn unary_without_side_effect() {
     i;
     !i;
     (i == 0) as std::ffi::c_int;
-    &mut i;
+    &raw mut i;
     i;
     i += 1;
     i -= 1;
@@ -44,10 +45,11 @@ pub unsafe extern "C" fn unary_with_side_effect() {
     side_effect();
     !side_effect();
     (side_effect() == 0) as std::ffi::c_int;
-    &*(b"\0" as *const u8 as *const std::ffi::c_char).offset(::core::mem::transmute::<
+    &raw const *(b"\0" as *const u8 as *const std::ffi::c_char).offset(::core::mem::transmute::<
         unsafe extern "C" fn() -> std::ffi::c_int,
         unsafe extern "C" fn() -> std::ffi::c_int,
-    >(side_effect)() as isize) as *const std::ffi::c_char;
+    >(side_effect)()
+        as isize);
     *arr[side_effect() as usize];
     arr[side_effect() as usize] = (arr[side_effect() as usize]).offset(1);
     arr[side_effect() as usize] = (arr[side_effect() as usize]).offset(-1);