Translate default pointers in globals (#63)

Previously, we used `Default::default()` for initializing pointers to
null. This is not compatible with initializing global variables because
they are declared in static context. In static context, only const
functions can be used. `Default::default()` is not const,
`std::ptr::null()/null_mut()` are const.

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -1862,7 +1862,9 @@ bool Converter::VisitImplicitCastExpr(clang::ImplicitCastExpr *expr) {
     if (type->isFunctionPointerType()) {
       StrCat("None");
     } else {
-      StrCat(keyword_default_);
+      StrCat(type->getPointeeType().isConstQualified()
+                 ? "std::ptr::null()"
+                 : "std::ptr::null_mut()");
     }
     computed_expr_type_ = ComputedExprType::FreshPointer;
     break;
@@ -2966,12 +2968,13 @@ std::string Converter::GetDefaultAsString(clang::QualType qual_type) {
   }
 
   if (qual_type->isPointerType()) {
-    if (qual_type->getPointeeType()->isFunctionType()) {
+    auto pointee = qual_type->getPointeeType();
+    if (pointee->isFunctionType()) {
       return "None";
-    } else {
-      computed_expr_type_ = ComputedExprType::FreshPointer;
-      return keyword_default_;
     }
+    computed_expr_type_ = ComputedExprType::FreshPointer;
+    return pointee.isConstQualified() ? "std::ptr::null()"
+                                      : "std::ptr::null_mut()";
   }
 
   computed_expr_type_ = ComputedExprType::FreshValue;

tests/benchmarks/out/unsafe/bfs.rs

@@ -134,14 +134,14 @@ unsafe fn main_0() -> i32 {
         V: (V as u32),
         adj: Box::leak(
             (0..V)
-                .map(|_| Default::default())
+                .map(|_| std::ptr::null_mut())
                 .collect::<Box<[*mut GraphNode]>>(),
         )
         .as_mut_ptr(),
     };
     let mut i: u32 = 0_u32;
     'loop_: while ((i as u64) < (V)) {
-        (*graph.adj.offset((i) as isize)) = Default::default();
+        (*graph.adj.offset((i) as isize)) = std::ptr::null_mut();
         i.prefix_inc();
     }
     let mut i: u32 = 0_u32;

tests/benchmarks/out/unsafe/bst.rs

@@ -29,7 +29,7 @@ pub unsafe fn find_0(mut node: *mut node_t, mut value: i32) -> *mut node_t {
     } else if ((value) == ((*node).value)) {
         return node;
     }
-    return Default::default();
+    return std::ptr::null_mut();
 }
 pub unsafe fn insert_1(mut node: *mut node_t, mut new_node: *mut node_t) -> *mut node_t {
     if (node).is_null() {
@@ -58,17 +58,17 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let N: i32 = 25000;
     let mut tree: *mut node_t = (Box::leak(Box::new(node_t {
-        left: Default::default(),
-        right: Default::default(),
+        left: std::ptr::null_mut(),
+        right: std::ptr::null_mut(),
         value: 0,
     })) as *mut node_t);
     let mut i: i32 = 0;
     'loop_: while ((i) < (N)) {
         (unsafe {
             let _node: *mut node_t = tree;
             let _new_node: *mut node_t = (Box::leak(Box::new(node_t {
-                left: Default::default(),
-                right: Default::default(),
+                left: std::ptr::null_mut(),
+                right: std::ptr::null_mut(),
                 value: i,
             })) as *mut node_t);
             insert_1(_node, _new_node)

tests/ub/out/unsafe/ub2.rs

@@ -7,7 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub unsafe fn null_0() -> *mut i32 {
-    let mut p: *mut i32 = Default::default();
+    let mut p: *mut i32 = std::ptr::null_mut();
     return p;
 }
 pub fn main() {

tests/ub/out/unsafe/ub4.rs

@@ -15,7 +15,7 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut out: *mut i32 = Default::default();
+    let mut out: *mut i32 = std::ptr::null_mut();
     let mut x1: i32 = 1;
     if (x1 != 0) {
         let mut x2: i32 = -1_i32;

tests/ub/out/unsafe/ub5.rs

@@ -7,7 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub unsafe fn null_0(mut p: *mut *mut i32) {
-    (*p) = Default::default();
+    (*p) = std::ptr::null_mut();
 }
 pub fn main() {
     unsafe {

tests/unit/null_in_statics.cpp

@@ -0,0 +1,27 @@
+#include <cassert>
+#include <cstddef>
+
+static int *p_mut;
+static const int *p_const;
+static const char *cp;
+static int *arr_of_ptr[4];
+static int **pp;
+static const int *const_arr_of_ptr[3];
+static const char *cp_explicit_null = nullptr;
+static int *p_zero = 0;
+
+int main() {
+  assert(p_mut == nullptr);
+  assert(p_const == nullptr);
+  assert(cp == nullptr);
+  for (int i = 0; i < 4; ++i) {
+    assert(arr_of_ptr[i] == nullptr);
+  }
+  assert(pp == nullptr);
+  for (int i = 0; i < 3; ++i) {
+    assert(const_arr_of_ptr[i] == nullptr);
+  }
+  assert(cp_explicit_null == nullptr);
+  assert(p_zero == nullptr);
+  return 0;
+}

tests/unit/out/refcount/null_in_statics.rs

@@ -0,0 +1,64 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+thread_local!(
+    pub static p_mut: Value<Ptr<i32>> = Rc::new(RefCell::new(Ptr::<i32>::null()));
+);
+thread_local!(
+    pub static p_const: Value<Ptr<i32>> = Rc::new(RefCell::new(Ptr::<i32>::null()));
+);
+thread_local!(
+    pub static cp: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::<u8>::null()));
+);
+thread_local!(
+    pub static arr_of_ptr: Value<Box<[Ptr<i32>]>> = Rc::new(RefCell::new(
+        (0..4)
+            .map(|_| Ptr::<i32>::null())
+            .collect::<Box<[Ptr<i32>]>>(),
+    ));
+);
+thread_local!(
+    pub static pp: Value<Ptr<Ptr<i32>>> = Rc::new(RefCell::new(Ptr::<Ptr<i32>>::null()));
+);
+thread_local!(
+    pub static const_arr_of_ptr: Value<Box<[Ptr<i32>]>> = Rc::new(RefCell::new(
+        (0..3)
+            .map(|_| Ptr::<i32>::null())
+            .collect::<Box<[Ptr<i32>]>>(),
+    ));
+);
+thread_local!(
+    pub static cp_explicit_null: Value<Ptr<u8>> = Rc::new(RefCell::new(Default::default()));
+);
+thread_local!(
+    pub static p_zero: Value<Ptr<i32>> = Rc::new(RefCell::new(Default::default()));
+);
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    assert!((*p_mut.with(Value::clone).borrow()).is_null());
+    assert!((*p_const.with(Value::clone).borrow()).is_null());
+    assert!((*cp.with(Value::clone).borrow()).is_null());
+    let i: Value<i32> = Rc::new(RefCell::new(0));
+    'loop_: while ((*i.borrow()) < 4) {
+        assert!(((*arr_of_ptr.with(Value::clone).borrow())[(*i.borrow()) as usize]).is_null());
+        (*i.borrow_mut()).prefix_inc();
+    }
+    assert!((*pp.with(Value::clone).borrow()).is_null());
+    let i: Value<i32> = Rc::new(RefCell::new(0));
+    'loop_: while ((*i.borrow()) < 3) {
+        assert!(
+            ((*const_arr_of_ptr.with(Value::clone).borrow())[(*i.borrow()) as usize]).is_null()
+        );
+        (*i.borrow_mut()).prefix_inc();
+    }
+    assert!((*cp_explicit_null.with(Value::clone).borrow()).is_null());
+    assert!((*p_zero.with(Value::clone).borrow()).is_null());
+    return 0;
+}

tests/unit/out/unsafe/10_struct.rs

@@ -38,7 +38,7 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut g: Graph = Graph {
         V: 5_u32,
-        adj: Default::default(),
+        adj: std::ptr::null_mut(),
     };
     return 0;
 }

tests/unit/out/unsafe/bool_condition_logical.rs

@@ -44,7 +44,7 @@ unsafe fn main_0() -> i32 {
     let mut zero: i32 = 0;
     let mut storage: i32 = 7;
     let mut p: *mut i32 = (&mut storage as *mut i32);
-    let mut np: *mut i32 = Default::default();
+    let mut np: *mut i32 = std::ptr::null_mut();
     let mut u: u32 = 4_u32;
     let mut code: Code = Code::CODE_OK;
     if (n != 0) && (!(p).is_null()) {
@@ -124,7 +124,7 @@ unsafe fn main_0() -> i32 {
         assert!(true);
     }
     let mut cp: *const u8 = b"hi\0".as_ptr();
-    let mut cnp: *const u8 = Default::default();
+    let mut cnp: *const u8 = std::ptr::null();
     if ((x) > (y)) && (!(cp).is_null()) {
         assert!(true);
     }