Fix #114: Rust 2024 compatibility

Author: nunoplopes

cpp2rust/converter/converter.cpp

@@ -22,6 +22,18 @@
 #include "converter/lex.h"
 #include "converter/mapper.h"
 
+// `static mut` globals cannot have a `&`/`&mut` reference formed directly to
+// them in Rust 2024 edition. Wrapping the variable in a `&raw mut` pointer
+// followed by a deref sidesteps the restriction.
+// Doesn't apply when a rule replaced the expression with custom Rust code.
+static std::string WrapMutableStaticPlace(const clang::Decl *decl, std::string str) {
+  if (IsGlobalVar(decl) && !decl->getType()->isReferenceType() &&
+      str == GetNamedDeclAsString(decl)) {
+    return std::format("(*&raw mut {})", str);
+  }
+  return str;
+}
+
 namespace cpp2rust {
 std::unordered_map<std::string, std::string> Converter::inner_structs_;
 std::unordered_set<std::string> Converter::decl_ids_;
@@ -272,7 +284,8 @@ Converter::MaterializeTemp(const std::string &binding_name,
 
   auto binding =
       std::format("{} mut {} : {} = {};", decl, binding_name, type_str, value);
-  auto ref = std::format("& mut {}", binding_name);
+  auto ref = in_const_initializer_ ? std::format("&raw mut {}", binding_name)
+                                   : std::format("& mut {}", binding_name);
   return {binding, ref};
 }
 
@@ -2870,6 +2883,8 @@ bool Converter::VisitDeclRefExpr(clang::DeclRefExpr *expr) {
   auto str = ConvertDeclRefExpr(expr);
   auto decl = expr->getDecl();
 
+  str = WrapMutableStaticPlace(decl, std::move(str));
+
   if (decl->getType()->getAs<clang::ReferenceType>() && !isAddrOf() &&
       !map_iter_decls_.contains(clang::dyn_cast<clang::VarDecl>(decl))) {
     EmitDeref(std::move(str), decl->getType().getNonReferenceType());

tests/lit/lit/formats/Cpp2RustTest.py

@@ -247,8 +247,6 @@ def build_rust(self):
             "strip=symbols",
             "-C",
             "panic=abort",
-            "-W",  ## TODO: remove this once we fix the errors in the generated code
-            "static_mut_refs",
             "--out-dir",
             str(self.tmp_dir),
             "-L",

tests/multi-file/static_name_collision/out/unsafe/static_name_collision.rs

@@ -9,10 +9,10 @@ use std::rc::Rc;
 pub static mut same_name_different_type_0: i32 = unsafe { 1 };
 pub static mut same_name_same_type_1: i32 = unsafe { 5 };
 pub unsafe fn a_foo_2() -> i32 {
-    return same_name_different_type_0;
+    return (*&raw mut same_name_different_type_0);
 }
 pub unsafe fn a_bar_3() -> i32 {
-    return same_name_same_type_1;
+    return (*&raw mut same_name_same_type_1);
 }
 pub fn main() {
     unsafe {
@@ -29,8 +29,8 @@ unsafe fn main_0() -> i32 {
 pub static mut same_name_different_type_6: f32 = unsafe { 1.0E+0 };
 pub static mut same_name_same_type_7: i32 = unsafe { 6 };
 pub unsafe fn b_foo_4() -> f32 {
-    return same_name_different_type_6;
+    return (*&raw mut same_name_different_type_6);
 }
 pub unsafe fn b_bar_5() -> i32 {
-    return same_name_same_type_7;
+    return (*&raw mut same_name_same_type_7);
 }

tests/unit/out/unsafe/addr_of_global.rs

@@ -21,13 +21,13 @@ pub static mut beta_1: Inner = unsafe { Inner { value: 2 } };
 pub static mut shared_2: Inner = unsafe { Inner { value: 42 } };
 pub static mut items_3: [*mut Inner; 2] = unsafe {
     [
-        (&raw mut alpha_0 as *mut Inner),
-        (&raw mut beta_1 as *mut Inner),
+        (&raw mut (*&raw mut alpha_0) as *mut Inner),
+        (&raw mut (*&raw mut beta_1) as *mut Inner),
     ]
 };
 pub static mut obj_4: Outer = unsafe {
     Outer {
-        p: (&raw mut shared_2 as *mut Inner),
+        p: (&raw mut (*&raw mut shared_2) as *mut Inner),
     }
 };
 pub fn main() {
@@ -36,16 +36,16 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    assert!((((*items_3[(0) as usize]).value) == (1)));
-    assert!((((*items_3[(1) as usize]).value) == (2)));
-    assert!((((*obj_4.p).value) == (42)));
+    assert!((((*(*&raw mut items_3)[(0) as usize]).value) == (1)));
+    assert!((((*(*&raw mut items_3)[(1) as usize]).value) == (2)));
+    assert!((((*(*&raw mut obj_4).p).value) == (42)));
     static mut cache_5: [*mut Inner; 2] = unsafe {
         [
-            (&raw mut alpha_0 as *mut Inner),
-            (&raw mut beta_1 as *mut Inner),
+            (&raw mut (*&raw mut alpha_0) as *mut Inner),
+            (&raw mut (*&raw mut beta_1) as *mut Inner),
         ]
     };;
-    assert!((((*cache_5[(0) as usize]).value) == (1)));
-    assert!((((*cache_5[(1) as usize]).value) == (2)));
+    assert!((((*(*&raw mut cache_5)[(0) as usize]).value) == (1)));
+    assert!((((*(*&raw mut cache_5)[(1) as usize]).value) == (2)));
     return 0;
 }

tests/unit/out/unsafe/array_const_init.rs

@@ -35,15 +35,15 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    assert!(((((s_0.head) == (5)) as i32) != 0));
+    assert!((((((*&raw mut s_0).head) == (5)) as i32) != 0));
     let mut i: i32 = 0;
     'loop_: while ((((i) < (3)) as i32) != 0) {
-        assert!(((((s_0.tail[(i) as usize]) == (0)) as i32) != 0));
+        assert!((((((*&raw mut s_0).tail[(i) as usize]) == (0)) as i32) != 0));
         i.postfix_inc();
     }
     let mut i: i32 = 0;
     'loop_: while ((((i) < (4)) as i32) != 0) {
-        assert!(((((s_0.buf[(i) as usize] as i32) == (0)) as i32) != 0));
+        assert!((((((*&raw mut s_0).buf[(i) as usize] as i32) == (0)) as i32) != 0));
         i.postfix_inc();
     }
     return 0;

tests/unit/out/unsafe/bool_condition_logical.rs

@@ -12,7 +12,7 @@ pub const Code_CODE_ERR: Code = 1;
 pub const Code_CODE_FATAL: Code = 2;
 pub static mut side_effect_0: i32 = unsafe { 0 };
 pub unsafe fn observe_1(mut v: i32) -> i32 {
-    side_effect_0.prefix_inc();
+    (*&raw mut side_effect_0).prefix_inc();
     return v;
 }
 pub unsafe fn returns_one_2() -> i32 {
@@ -49,15 +49,15 @@ unsafe fn main_0() -> i32 {
     if (((n != 0) && (u != 0)) && (!(p).is_null())) && ((code as i32) == (Code_CODE_OK as i32)) {
         assert!(true);
     }
-    side_effect_0 = 0;
+    (*&raw mut side_effect_0) = 0;
     if (zero != 0) && ((unsafe { observe_1(1) }) != 0) {
         assert!(false);
     }
-    assert!(((side_effect_0) == (0)));
+    assert!(((*&raw mut side_effect_0) == (0)));
     if (n != 0) || ((unsafe { observe_1(1) }) != 0) {
         assert!(true);
     }
-    assert!(((side_effect_0) == (0)));
+    assert!(((*&raw mut side_effect_0) == (0)));
     let mut x: i32 = 5;
     let mut y: i32 = 3;
     let mut flags: u32 = 2_u32;

tests/unit/out/unsafe/bool_condition_logical_c.rs

@@ -12,7 +12,7 @@ pub const Code_CODE_ERR: Code = 1;
 pub const Code_CODE_FATAL: Code = 2;
 pub static mut side_effect_0: i32 = unsafe { 0 };
 pub unsafe fn observe_1(mut v: i32) -> i32 {
-    side_effect_0.prefix_inc();
+    (*&raw mut side_effect_0).prefix_inc();
     return v;
 }
 pub unsafe fn returns_one_2() -> i32 {
@@ -52,15 +52,15 @@ unsafe fn main_0() -> i32 {
     {
         assert!((1 != 0));
     }
-    side_effect_0 = 0;
+    (*&raw mut side_effect_0) = 0;
     if ((((zero != 0) && ((unsafe { observe_1(1) }) != 0)) as i32) != 0) {
         assert!((0 != 0));
     }
-    assert!(((((side_effect_0) == (0)) as i32) != 0));
+    assert!(((((*&raw mut side_effect_0) == (0)) as i32) != 0));
     if ((((n != 0) || ((unsafe { observe_1(1) }) != 0)) as i32) != 0) {
         assert!((1 != 0));
     }
-    assert!(((((side_effect_0) == (0)) as i32) != 0));
+    assert!(((((*&raw mut side_effect_0) == (0)) as i32) != 0));
     let mut x: i32 = 5;
     let mut y: i32 = 3;
     let mut flags: u32 = 2_u32;

tests/unit/out/unsafe/constructor.rs

@@ -22,12 +22,12 @@ impl S {
     pub unsafe fn S(mut init: i32) -> Self {
         let mut this = Self { v: init };
         (unsafe { S::mut_method(&mut this) });
-        total_0 += (unsafe { S::const_method(&mut this) });
+        (*&raw mut total_0) += (unsafe { S::const_method(&mut this) });
         this
     }
     pub unsafe fn destructor(&mut self) {
         (unsafe { S::mut_method(self) });
-        total_0 += (unsafe { S::const_method(self) });
+        (*&raw mut total_0) += (unsafe { S::const_method(self) });
     }
 }
 pub fn main() {
@@ -40,8 +40,8 @@ unsafe fn main_0() -> i32 {
         let mut s: S = S::S({ 3 });
         let _dtor_s = ScopedDestructorUnsafe::new(&raw mut s, S::destructor);
         assert!(((s.v) == (4)));
-        assert!(((total_0) == (8)));
+        assert!(((*&raw mut total_0) == (8)));
     }
-    assert!(((total_0) == (18)));
+    assert!(((*&raw mut total_0) == (18)));
     return 0;
 }

tests/unit/out/unsafe/copy_assign.rs

@@ -30,7 +30,7 @@ impl Partial {
             return &mut (*(self as *mut Partial)) as *mut Partial;
         }
         self.v = (*o).v;
-        assigns_0.prefix_inc();
+        (*&raw mut assigns_0).prefix_inc();
         return &mut (*(self as *mut Partial)) as *mut Partial;
     }
 }
@@ -114,7 +114,7 @@ unsafe fn main_0() -> i32 {
     let mut c: Partial = Partial::Partial({ 3 }, { 300 });
     (unsafe { Partial::operator_assign(&mut a, &b as *const Partial) });
     assert!(((a.v) == (2)) && ((a.keep) == (100)));
-    assert!(((assigns_0) == (1)));
+    assert!(((*&raw mut assigns_0) == (1)));
     (unsafe {
         Partial::operator_assign(
             &mut c,
@@ -123,18 +123,18 @@ unsafe fn main_0() -> i32 {
         )
     });
     assert!(((c.v) == (2)) && ((c.keep) == (300)));
-    assert!(((assigns_0) == (3)));
+    assert!(((*&raw mut assigns_0) == (3)));
     (unsafe {
         let _o: *const Partial = &a as *const Partial;
         Partial::operator_assign(&mut a, _o)
     });
-    assert!(((assigns_0) == (3)));
+    assert!(((*&raw mut assigns_0) == (3)));
     (unsafe {
         let mut _o: Partial = Partial::Partial({ 9 }, { 900 });
         Partial::operator_assign(&mut a, &mut _o)
     });
     assert!(((a.v) == (9)) && ((a.keep) == (100)));
-    assert!(((assigns_0) == (4)));
+    assert!(((*&raw mut assigns_0) == (4)));
     let ra: *mut Partial = &mut a as *mut Partial;
     (unsafe {
         let _o: *const Partial = &c as *const Partial;
@@ -147,7 +147,7 @@ unsafe fn main_0() -> i32 {
         Partial::operator_assign(&mut (*pa), _o)
     });
     assert!(((a.v) == (2)));
-    assert!(((assigns_0) == (6)));
+    assert!(((*&raw mut assigns_0) == (6)));
     let mut h: Holder = Holder {
         p: Partial::Partial({ 4 }, { 40 }),
         arr: [
@@ -159,7 +159,7 @@ unsafe fn main_0() -> i32 {
     (unsafe { Partial::operator_assign(&mut h.arr[(1) as usize], &c as *const Partial) });
     assert!(((h.p.v) == (2)) && ((h.p.keep) == (40)));
     assert!(((h.arr[(1) as usize].v) == (2)) && ((h.arr[(1) as usize].keep) == (60)));
-    assert!(((assigns_0) == (8)));
+    assert!(((*&raw mut assigns_0) == (8)));
     let mut n: NonConstAssign = NonConstAssign::NonConstAssign();
     let mut n1: NonConstAssign = NonConstAssign::NonConstAssign();
     let mut n2: NonConstAssign = NonConstAssign::NonConstAssign();

tests/unit/out/unsafe/copy_ctor.rs

@@ -19,7 +19,7 @@ impl Counted {
     }
     pub unsafe fn Counted_pconstCounted(o: *const Counted) -> Self {
         let mut this = Self { v: (*o).v };
-        copies_0.prefix_inc();
+        (*&raw mut copies_0).prefix_inc();
         this
     }
 }
@@ -92,23 +92,23 @@ unsafe fn main_0() -> i32 {
     let mut b: Counted = Counted::Counted_pconstCounted({ &a as *const Counted });
     let mut c: Counted = Counted::Counted_pconstCounted({ &a as *const Counted });
     let mut d: Counted = Counted::Counted_pconstCounted({ &a as *const Counted });
-    assert!(((copies_0) == (3)));
+    assert!(((*&raw mut copies_0) == (3)));
     assert!((((b.v) == (1)) && ((c.v) == (1))) && ((d.v) == (1)));
     assert!(
         ((unsafe { by_value_1(Counted::Counted_pconstCounted({ &a as *const Counted },),) })
             == (1))
     );
-    assert!(((copies_0) == (4)));
+    assert!(((*&raw mut copies_0) == (4)));
     let mut e: Counted = (unsafe { make_2(5) });
     assert!(((e.v) == (5)));
-    assert!(((copies_0) == (5)));
+    assert!(((*&raw mut copies_0) == (5)));
     let mut f: Counted = Counted::Counted({ 6 });
     assert!(((f.v) == (6)));
-    assert!(((copies_0) == (5)));
+    assert!(((*&raw mut copies_0) == (5)));
     let g: Counted = Counted::Counted({ 7 });
     let mut h: Counted = Counted::Counted_pconstCounted({ &g as *const Counted });
     assert!(((h.v) == (7)));
-    assert!(((copies_0) == (6)));
+    assert!(((*&raw mut copies_0) == (6)));
     let mut hold: Holder = Holder {
         c: Counted::Counted({ 8 }),
         arr: [Counted::Counted({ 9 }), Counted::Counted({ 10 })],
@@ -118,14 +118,14 @@ unsafe fn main_0() -> i32 {
         (((hold2.c.v) == (8)) && ((hold2.arr[(0) as usize].v) == (9)))
             && ((hold2.arr[(1) as usize].v) == (10))
     );
-    assert!(((copies_0) == (9)));
+    assert!(((*&raw mut copies_0) == (9)));
     let mut vec_: Vec<Counted> = Vec::new();
     {
         let a0_clone = a.clone();
         vec_.push(a0_clone)
     };
     assert!(((vec_[(0_usize)].v) == (1)));
-    assert!(((copies_0) == (10)));
+    assert!(((*&raw mut copies_0) == (10)));
     let mut n: NonConst = NonConst::NonConst();
     let mut n1: NonConst = NonConst::NonConst_pmutNonConst({ &mut n as *mut NonConst });
     let cn: NonConst = NonConst::NonConst();