Allow default initialization in static variables

cpp2rust/converter/converter.cpp

@@ -383,9 +383,15 @@ bool Converter::ConvertVarDeclSkipInit(clang::VarDecl *decl) {
       return false;
     }
     StrCat(AccessSpecifierAsString(decl->getAccess()), keyword::kStatic);
+    if (!qual_type.isConstQualified()) {
+      StrCat(keyword_mut_);
+    }
     ENSURE(decl_ids_.insert(GetID(decl)).second);
   } else if (decl->isStaticLocal()) {
     StrCat(keyword::kStatic);
+    if (!qual_type.isConstQualified()) {
+      StrCat(keyword_mut_);
+    }
   } else if (decl->isLocalVarDecl()) {
     StrCat(keyword::kLet);
   }
@@ -2679,18 +2685,18 @@ std::string Converter::GetDefaultAsString(clang::QualType qual_type) {
 }
 
 std::string Converter::GetDefaultAsStringFallback(clang::QualType qual_type) {
-  static llvm::DenseMap<unsigned, std::string> default_for_type = {
-      {clang::BuiltinType::Char_U, "0_u8"},
-      {clang::BuiltinType::SChar, "0_i8"},
-      {clang::BuiltinType::UChar, "0_u8"},
-  };
-
   qual_type = qual_type.getUnqualifiedType().getCanonicalType();
-  if (auto builtin = qual_type->getAs<clang::BuiltinType>()) {
-    auto it = default_for_type.find(builtin->getKind());
-    if (it != default_for_type.end()) {
-      return it->second;
-    }
+
+  if (qual_type->isBooleanType()) {
+    return "false";
+  }
+
+  if (qual_type->isIntegerType() && !qual_type->isEnumeralType()) {
+    return std::format("0_{}", ToString(qual_type));
+  }
+
+  if (qual_type->isFloatingType()) {
+    return std::format("0.0_{}", ToString(qual_type));
   }
 
   return std::format("<{}>::default()", ToString(qual_type));

tests/benchmarks/out/unsafe/bfs.rs

@@ -62,7 +62,7 @@ pub unsafe fn BFS_0(graph: *const Graph, mut start_vertex: u32) -> *mut u32 {
     let mut Q: Queue = Queue {
         elems: Box::leak(
             (0..((*graph).V as u64))
-                .map(|_| <u32>::default())
+                .map(|_| 0_u32)
                 .collect::<Box<[u32]>>(),
         )
         .as_mut_ptr(),
@@ -72,13 +72,13 @@ pub unsafe fn BFS_0(graph: *const Graph, mut start_vertex: u32) -> *mut u32 {
     };
     let mut visited: *mut bool = Box::leak(
         (0..((*graph).V as u64))
-            .map(|_| <bool>::default())
+            .map(|_| false)
             .collect::<Box<[bool]>>(),
     )
     .as_mut_ptr();
     let mut pred: *mut u32 = Box::leak(
         (0..((*graph).V as u64))
-            .map(|_| <u32>::default())
+            .map(|_| 0_u32)
             .collect::<Box<[u32]>>(),
     )
     .as_mut_ptr();

tests/ub/out/unsafe/ub10.rs

@@ -13,12 +13,8 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut arr: *mut i32 = Box::leak(
-        (0..10_u64)
-            .map(|_| <i32>::default())
-            .collect::<Box<[i32]>>(),
-    )
-    .as_mut_ptr();
+    let mut arr: *mut i32 =
+        Box::leak((0..10_u64).map(|_| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();
     let mut ptr: *mut i32 = arr.offset((1) as isize);
     let mut out: i32 = (*ptr);
 

tests/ub/out/unsafe/ub14.rs

@@ -13,12 +13,8 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut arr1: *mut i32 = Box::leak(
-        (0..100_u64)
-            .map(|_| <i32>::default())
-            .collect::<Box<[i32]>>(),
-    )
-    .as_mut_ptr();
+    let mut arr1: *mut i32 =
+        Box::leak((0..100_u64).map(|_| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();
     (*arr1.offset((100) as isize)) = 1;
 
     ::std::mem::drop(Box::from_raw(::std::slice::from_raw_parts_mut(

tests/ub/out/unsafe/ub15.rs

@@ -13,12 +13,8 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut arr: *mut i32 = Box::leak(
-        (0..15_u64)
-            .map(|_| <i32>::default())
-            .collect::<Box<[i32]>>(),
-    )
-    .as_mut_ptr();
+    let mut arr: *mut i32 =
+        Box::leak((0..15_u64).map(|_| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();
     let mut ptr: *mut i32 = arr.offset((15) as isize);
     let mut out: i32 = (*ptr);
 

tests/ub/out/unsafe/ub16.rs

@@ -16,12 +16,8 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut p1: *mut i32 = Box::leak(
-        (0..10_u64)
-            .map(|_| <i32>::default())
-            .collect::<Box<[i32]>>(),
-    )
-    .as_mut_ptr();
+    let mut p1: *mut i32 =
+        Box::leak((0..10_u64).map(|_| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();
     let mut out: i32 = (*(unsafe {
         let _a: *mut i32 = (&mut (*p1.offset((1) as isize)) as *mut i32);
         foo_0(_a)

tests/ub/out/unsafe/ub20.rs

@@ -16,12 +16,8 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut x: *mut i32 = Box::leak(
-        (0..10_u64)
-            .map(|_| <i32>::default())
-            .collect::<Box<[i32]>>(),
-    )
-    .as_mut_ptr();
+    let mut x: *mut i32 =
+        Box::leak((0..10_u64).map(|_| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();
     (unsafe {
         let _single: *mut i32 = x;
         foo_0(_single)

tests/ub/out/unsafe/ub9.rs

@@ -13,12 +13,8 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut arr: *mut i32 = Box::leak(
-        (0..10_u64)
-            .map(|_| <i32>::default())
-            .collect::<Box<[i32]>>(),
-    )
-    .as_mut_ptr();
+    let mut arr: *mut i32 =
+        Box::leak((0..10_u64).map(|_| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();
     let mut out: i32 = (*arr.offset((10) as isize));
 
     ::std::mem::drop(Box::from_raw(::std::slice::from_raw_parts_mut(

tests/unit/out/refcount/static_local.rs

@@ -8,14 +8,24 @@ use std::io::{Read, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn foo_0() -> i32 {
+    thread_local!(
+        static static_i: Value<i32> = <Value<i32>>::default();
+    );
+    thread_local!(
+        static static_f: Value<f32> = <Value<f32>>::default();
+    );
+    thread_local!(
+        static static_b: Value<bool> = <Value<bool>>::default();
+    );
     thread_local!(
         static kX1: Value<i32> = Rc::new(RefCell::new(1));
     );
     thread_local!(
         static kX2: Value<i32> = Rc::new(RefCell::new(2));
     );
     (*kX1.with(Value::clone).borrow_mut()) += 1;
-    return ((*kX1.with(Value::clone).borrow()) + (*kX2.with(Value::clone).borrow()));
+    return (((*kX1.with(Value::clone).borrow()) + (*kX2.with(Value::clone).borrow()))
+        + (*static_i.with(Value::clone).borrow()));
 }
 pub fn main() {
     std::process::exit(main_0());

tests/unit/out/unsafe/06_new_array.rs

@@ -13,8 +13,7 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut e: *mut i32 =
-        Box::leak((0..2_u64).map(|_| <i32>::default()).collect::<Box<[i32]>>()).as_mut_ptr();
+    let mut e: *mut i32 = Box::leak((0..2_u64).map(|_| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();
     (*e.offset((0) as isize)) = 6;
     (*e.offset((1) as isize)) = 7;
 

tests/unit/out/unsafe/clone_vs_move.rs

@@ -22,10 +22,10 @@ pub struct Foo {
 impl Default for Foo {
     fn default() -> Self {
         Foo {
-            x: <i32>::default(),
+            x: 0_i32,
             y: <*mut i32>::default(),
             z: Default::default(),
-            a: [<i32>::default(); 3],
+            a: [0_i32; 3],
             bar: <Bar>::default(),
         }
     }

tests/unit/out/unsafe/default.rs

@@ -22,7 +22,7 @@ impl Default for Pointers {
             x2: Default::default(),
             x3: [Default::default(); 5],
             x4: [Default::default(); 10],
-            x5: <i32>::default(),
+            x5: 0_i32,
         }
     }
 }

tests/unit/out/unsafe/init.rs

@@ -20,7 +20,7 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut x: i32 = <i32>::default();
+    let mut x: i32 = 0_i32;
     let mut p: *mut i32 = Default::default();
     let g: *mut i32 = &mut x as *mut i32;
     let mut q: *mut i32 = (&mut x as *mut i32);

tests/unit/out/unsafe/init_list.rs

@@ -15,9 +15,9 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut i1: i32 = 3;
-    let mut i2: i32 = <i32>::default();
+    let mut i2: i32 = 0_i32;
     let mut carr1: [i32; 2] = [1, 2];
-    let mut carr2: [i32; 3] = [1, <i32>::default(), <i32>::default()];
+    let mut carr2: [i32; 3] = [1, 0_i32, 0_i32];
     let mut arr: Vec<i32> = vec![1, 2, 3];
     let mut vec_: Vec<i32> = vec![1, 2, 3];
     (unsafe {

tests/unit/out/unsafe/memset.rs

@@ -14,12 +14,8 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let N: i32 = 3;
-    let mut arr: *mut i32 = Box::leak(
-        (0..(N as u64))
-            .map(|_| <i32>::default())
-            .collect::<Box<[i32]>>(),
-    )
-    .as_mut_ptr();
+    let mut arr: *mut i32 =
+        Box::leak((0..(N as u64)).map(|_| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();
     {
         let byte_0 = (arr as *mut i32 as *mut ::libc::c_void) as *mut u8;
         for offset in 0..(::std::mem::size_of::<i32>() as u64 as u64).wrapping_mul((N as u64)) {

tests/unit/out/unsafe/new_alloc_array.rs

@@ -13,12 +13,8 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut array: *mut i32 = Box::leak(
-        (0..100_u64)
-            .map(|_| <i32>::default())
-            .collect::<Box<[i32]>>(),
-    )
-    .as_mut_ptr();
+    let mut array: *mut i32 =
+        Box::leak((0..100_u64).map(|_| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();
     {
         let byte_0 = (array as *mut i32 as *mut ::libc::c_void) as *mut u8;
         for offset in 0..(::std::mem::size_of::<i32>() as u64 as u64).wrapping_mul(100_u64) {

tests/unit/out/unsafe/new_array.rs

@@ -13,12 +13,8 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut array: *mut i32 = Box::leak(
-        (0..100_u64)
-            .map(|_| <i32>::default())
-            .collect::<Box<[i32]>>(),
-    )
-    .as_mut_ptr();
+    let mut array: *mut i32 =
+        Box::leak((0..100_u64).map(|_| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();
 
     ::std::mem::drop(Box::from_raw(::std::slice::from_raw_parts_mut(
         array,

tests/unit/out/unsafe/new_array_var_size.rs

@@ -14,24 +14,16 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut N: i32 = 5;
-    let mut A: *mut i32 = Box::leak(
-        (0..(N as u64))
-            .map(|_| <i32>::default())
-            .collect::<Box<[i32]>>(),
-    )
-    .as_mut_ptr();
+    let mut A: *mut i32 =
+        Box::leak((0..(N as u64)).map(|_| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();
 
     ::std::mem::drop(Box::from_raw(::std::slice::from_raw_parts_mut(
         A,
         libcc2rs::malloc_usable_size(A as *mut ::libc::c_void) / ::std::mem::size_of::<i32>(),
     )));
     let N2: *mut i32 = &mut N as *mut i32;
-    let mut A2: *mut i32 = Box::leak(
-        (0..((*N2) as u64))
-            .map(|_| <i32>::default())
-            .collect::<Box<[i32]>>(),
-    )
-    .as_mut_ptr();
+    let mut A2: *mut i32 =
+        Box::leak((0..((*N2) as u64)).map(|_| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();
 
     ::std::mem::drop(Box::from_raw(::std::slice::from_raw_parts_mut(
         A2,

tests/unit/out/unsafe/pointer_call_offset.rs

@@ -16,12 +16,8 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut p1: *mut i32 = Box::leak(
-        (0..10_u64)
-            .map(|_| <i32>::default())
-            .collect::<Box<[i32]>>(),
-    )
-    .as_mut_ptr();
+    let mut p1: *mut i32 =
+        Box::leak((0..10_u64).map(|_| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();
     let mut i: u32 = 0_u32;
     'loop_: while ((i) < (10_u32)) {
         (*p1.offset((i) as isize)) = (i as i32);

tests/unit/out/unsafe/random.rs

@@ -40,9 +40,9 @@ impl Pair {
 impl Default for Pair {
     fn default() -> Self {
         Pair {
-            x: <i32>::default(),
-            y: <i32>::default(),
-            a: [<i32>::default(); 5],
+            x: 0_i32,
+            y: 0_i32,
+            a: [0_i32; 5],
             r: <*mut i32>::default(),
             p: Default::default(),
             pair: Default::default(),

tests/unit/out/unsafe/reinterpret_cast_large_array.rs

@@ -14,12 +14,8 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let N: i32 = 10000;
-    let mut arr: *mut u32 = Box::leak(
-        (0..(N as u64))
-            .map(|_| <u32>::default())
-            .collect::<Box<[u32]>>(),
-    )
-    .as_mut_ptr();
+    let mut arr: *mut u32 =
+        Box::leak((0..(N as u64)).map(|_| 0_u32).collect::<Box<[u32]>>()).as_mut_ptr();
     let mut i: i32 = 0;
     'loop_: while ((i) < (N)) {
         (*arr.offset((i) as isize)) = 0_u32;

tests/unit/out/unsafe/reinterpret_cast_new_array.rs

@@ -14,7 +14,7 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut arr: *mut u32 =
-        Box::leak((0..2_u64).map(|_| <u32>::default()).collect::<Box<[u32]>>()).as_mut_ptr();
+        Box::leak((0..2_u64).map(|_| 0_u32).collect::<Box<[u32]>>()).as_mut_ptr();
     (*arr.offset((0) as isize)) = 67305985_u32;
     (*arr.offset((1) as isize)) = 134678021_u32;
     let mut bytes: *mut u8 = (arr as *mut u8);

tests/unit/out/unsafe/static_local.rs

@@ -8,10 +8,13 @@ use std::io::{Read, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub unsafe fn foo_0() -> i32 {
-    static kX1: i32 = 1;;
+    static mut static_i: i32 = 0_i32;;
+    static mut static_f: f32 = 0.0_f32;;
+    static mut static_b: bool = false;;
+    static mut kX1: i32 = 1;;
     static kX2: i32 = 2;;
     kX1 += 1;
-    return ((kX1) + (kX2));
+    return (((kX1) + (kX2)) + (static_i));
 }
 pub fn main() {
     unsafe {

tests/unit/out/unsafe/stdcopy.rs

@@ -14,7 +14,7 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut input: [i32; 3] = [1, 2, 3];
-    let mut output: [i32; 3] = [<i32>::default(); 3];
+    let mut output: [i32; 3] = [0_i32; 3];
     {
         let mut outptr = output.as_mut_ptr().clone();
         let mut curr = input.as_mut_ptr().clone();

tests/unit/out/unsafe/swap_extended.rs

@@ -94,7 +94,7 @@ unsafe fn main_0() -> i32 {
         (*h),
     );
     ::std::mem::drop(Box::from_raw(h));
-    let mut i: *mut i32 = Box::leak(Box::new([7, 8, <i32>::default()])).as_mut_ptr();
+    let mut i: *mut i32 = Box::leak(Box::new([7, 8, 0_i32])).as_mut_ptr();
     write!(
         std::fs::File::from_raw_fd(
             std::io::stdout()