Fix translation of nullptr creation and comparison (#81)

This PR translates default pointers using `GetDefaultAsString`,
resulting in `Ptr::<T>::null()` being generated instead of
`Default::default()`. This is useful for contexts where
`Default::default()` cannot be correctly deduced as a `Ptr`.

Pointer comparisson is also fixed to allow C NULL comparissons such as
`p != NULL` or `p != 0`.

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -1871,13 +1871,7 @@ bool Converter::VisitImplicitCastExpr(clang::ImplicitCastExpr *expr) {
     ConvertEqualsNullPtr(sub_expr);
     break;
   case clang::CastKind::CK_NullToPointer:
-    if (type->isFunctionPointerType()) {
-      StrCat("None");
-    } else {
-      StrCat(type->getPointeeType().isConstQualified()
-                 ? "std::ptr::null()"
-                 : "std::ptr::null_mut()");
-    }
+    StrCat(GetDefaultAsString(type));
     computed_expr_type_ = ComputedExprType::FreshPointer;
     break;
   default:

cpp2rust/converter/converter_lib.cpp

@@ -105,13 +105,21 @@ bool IsBuiltinConstantP(const clang::Expr *expr) {
 }
 
 bool IsComparisonWithNullOp(const clang::BinaryOperator *expr) {
-  const auto *rhs = expr->getRHS()->IgnoreCasts();
-  switch (rhs->getStmtClass()) {
-  case clang::Stmt::CXXNullPtrLiteralExprClass:
-    return expr->isComparisonOp();
-  default:
+  if (!expr->isComparisonOp()) {
     return false;
   }
+  auto rhs = expr->getRHS()->IgnoreParenCasts();
+  // C++ nullptr/NULL
+  if (clang::isa<clang::CXXNullPtrLiteralExpr>(rhs) ||
+      clang::isa<clang::GNUNullExpr>(rhs)) {
+    return true;
+  }
+  // C NULL
+  if (auto lit = clang::dyn_cast<clang::IntegerLiteral>(rhs)) {
+    return lit->getValue() == 0 &&
+           expr->getLHS()->IgnoreParenImpCasts()->getType()->isPointerType();
+  }
+  return false;
 }
 
 bool IsInMainFile(const clang::Decl *decl) {

cpp2rust/converter/models/converter_refcount.cpp

@@ -1048,11 +1048,8 @@ bool ConverterRefCount::VisitImplicitCastExpr(clang::ImplicitCastExpr *expr) {
   }
 
   if (expr->getCastKind() == clang::CastKind::CK_NullToPointer) {
-    if (expr->getType()->isFunctionPointerType()) {
-      StrCat("FnPtr::null()");
-    } else {
-      StrCat("Default::default()");
-    }
+    PushConversionKind push(*this, ConversionKind::Unboxed);
+    StrCat(GetDefaultAsString(expr->getType()));
     computed_expr_type_ = ComputedExprType::FreshPointer;
     return false;
   }
@@ -1142,7 +1139,7 @@ bool ConverterRefCount::VisitExplicitCastExpr(clang::ExplicitCastExpr *expr) {
     return false;
   }
   if (expr->getCastKind() == clang::CK_NullToPointer) {
-    StrCat("Default::default()");
+    StrCat(GetDefaultAsString(expr->getType()));
     computed_expr_type_ = ComputedExprType::FreshPointer;
     return false;
   }
@@ -1163,7 +1160,7 @@ bool ConverterRefCount::VisitExplicitCastExpr(clang::ExplicitCastExpr *expr) {
       Convert(expr->getSubExpr());
       PushConversionKind push(*this, ConversionKind::Unboxed);
       StrCat(std::format(".cast::<{}>().expect(\"ub:wrong type\")",
-                         ToString(expr->getType()->getPointeeType())));
+                         ConvertPointeeType(expr->getType())));
       return false;
     } else if (expr->getSubExpr()->getType()->isPointerType() &&
                !expr->getSubExpr()->isNullPointerConstant(
@@ -1612,7 +1609,10 @@ bool ConverterRefCount::VisitVAArgExpr(clang::VAArgExpr *expr) {
   }
   StrCat(ConvertLValue(va_list_expr));
   StrCat(".arg::<");
-  StrCat(GetUnsafeTypeAsString(expr->getType()));
+  {
+    PushConversionKind push(*this, ConversionKind::Unboxed);
+    StrCat(ToString(expr->getType()));
+  }
   StrCat(">()");
   return false;
 }
@@ -2241,8 +2241,9 @@ std::string ConverterRefCount::ConvertMappedMethodCall(
 
 std::string ConverterRefCount::ConvertPointeeType(clang::QualType ptr_type) {
   assert(!ptr_type.isNull() && ptr_type->isPointerType());
-  if (ptr_type->getPointeeType()->isIntegerType()) {
-    return ToString(ptr_type->getPointeeType());
+  auto pointee = ptr_type->getPointeeType();
+  if (!pointee->isRecordType()) {
+    return ToString(pointee);
   }
 
   // Pointee of a pointer to incomplete type is an incomplete type that does

tests/benchmarks/out/refcount/bfs.rs

@@ -206,7 +206,7 @@ fn main_0() -> i32 {
     'loop_: while (((*i.borrow()) as u64) < (*V.borrow())) {
         (*(*graph.borrow()).adj.borrow())
             .offset((*i.borrow()) as isize)
-            .write(Default::default());
+            .write(Ptr::<GraphNode>::null());
         (*i.borrow_mut()).prefix_inc();
     }
     let i: Value<u32> = Rc::new(RefCell::new(0_u32));

tests/benchmarks/out/refcount/bst.rs

@@ -53,7 +53,7 @@ pub fn find_0(node: Ptr<node_t>, value: i32) -> Ptr<node_t> {
     } {
         return (*node.borrow()).clone();
     }
-    return Default::default();
+    return Ptr::<node_t>::null();
 }
 pub fn insert_1(node: Ptr<node_t>, new_node: Ptr<node_t>) -> Ptr<node_t> {
     let node: Value<Ptr<node_t>> = Rc::new(RefCell::new(node));
@@ -91,17 +91,17 @@ pub fn main() {
 fn main_0() -> i32 {
     let N: Value<i32> = Rc::new(RefCell::new(25000));
     let tree: Value<Ptr<node_t>> = Rc::new(RefCell::new(Ptr::alloc(node_t {
-        left: Rc::new(RefCell::new(Default::default())),
-        right: Rc::new(RefCell::new(Default::default())),
+        left: Rc::new(RefCell::new(Ptr::<node_t>::null())),
+        right: Rc::new(RefCell::new(Ptr::<node_t>::null())),
         value: Rc::new(RefCell::new(0)),
     })));
     let i: Value<i32> = Rc::new(RefCell::new(0));
     'loop_: while ((*i.borrow()) < (*N.borrow())) {
         ({
             let _node: Ptr<node_t> = (*tree.borrow()).clone();
             let _new_node: Ptr<node_t> = Ptr::alloc(node_t {
-                left: Rc::new(RefCell::new(Default::default())),
-                right: Rc::new(RefCell::new(Default::default())),
+                left: Rc::new(RefCell::new(Ptr::<node_t>::null())),
+                right: Rc::new(RefCell::new(Ptr::<node_t>::null())),
                 value: Rc::new(RefCell::new((*i.borrow()))),
             });
             insert_1(_node, _new_node)

tests/ub/out/refcount/ub2.rs

@@ -7,7 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn null_0() -> Ptr<i32> {
-    let p: Value<Ptr<i32>> = Rc::new(RefCell::new(Default::default()));
+    let p: Value<Ptr<i32>> = Rc::new(RefCell::new(Ptr::<i32>::null()));
     return (*p.borrow()).clone();
 }
 pub fn main() {

tests/ub/out/refcount/ub4.rs

@@ -20,7 +20,7 @@ pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    let out: Value<Ptr<i32>> = Rc::new(RefCell::new(Default::default()));
+    let out: Value<Ptr<i32>> = Rc::new(RefCell::new(Ptr::<i32>::null()));
     let x1: Value<i32> = Rc::new(RefCell::new(1));
     if ((*x1.borrow()) != 0) {
         let x2: Value<i32> = Rc::new(RefCell::new(-1_i32));

tests/ub/out/refcount/ub5.rs

@@ -8,7 +8,7 @@ use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn null_0(p: Ptr<Ptr<i32>>) {
     let p: Value<Ptr<Ptr<i32>>> = Rc::new(RefCell::new(p));
-    (*p.borrow()).write(Default::default());
+    (*p.borrow()).write(Ptr::<i32>::null());
 }
 pub fn main() {
     std::process::exit(main_0());

tests/unit/null_compare.c

@@ -0,0 +1,13 @@
+#include <assert.h>
+#include <stdlib.h>
+int main() {
+  int a = 0;
+  int *p = &a;
+  assert(p != NULL);
+  assert(p != 0);
+
+  p = NULL;
+  assert(p == NULL);
+  assert(p == 0);
+  return 0;
+}

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

@@ -66,7 +66,7 @@ pub fn main() {
 fn main_0() -> i32 {
     let g: Value<Graph> = Rc::new(RefCell::new(Graph {
         V: Rc::new(RefCell::new(5_u32)),
-        adj: Rc::new(RefCell::new(Default::default())),
+        adj: Rc::new(RefCell::new(Ptr::<Ptr<GraphNode>>::null())),
     }));
     return 0;
 }