Translate char as libc::c_char in unsafe (#194)

Translates char as c_char instead of u8 in both unsafe. Refcount is
unchanged.

This contains:
1. change all unsafe rules to use c_char instead of u8
2. use c_char instead of u8 in mapper and VisitBuiltinType
3. use c_char in argv for both unsafe
4. delete the IsCharPointerFieldFromLibc and IsCharArrayFieldFromLibc
hacks
5. use the edition 2024 `c""` syntax to define c_char compatible string
literals
6. use getTypedLiteral to write `0 as c_char` (correct) instead of
`0_c_char` (incorrect)

The big advantage of this PR is 4. IsCharPointerFieldFromLibc and
IsCharArrayFieldFromLibc were temporary solutions to interact between
our u8 and libc's c_char. After this PR, both functions are deleted.

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -123,8 +123,13 @@ bool Converter::VisitBuiltinType(clang::BuiltinType *type) {
     StrCat("f64");
     break;
   case clang::BuiltinType::Char_S:
-  case clang::BuiltinType::UChar:
+  case clang::BuiltinType::Char_U:
+    StrCat(CharRustType());
+    break;
   case clang::BuiltinType::SChar:
+    StrCat("i8");
+    break;
+  case clang::BuiltinType::UChar:
     StrCat("u8");
     break;
   case clang::BuiltinType::UShort:
@@ -1410,7 +1415,8 @@ bool Converter::GetFmtArg(clang::Expr *arg, std::string &fmt,
   } else if (arg_str.contains("Setw")) {
     fmt_width = Trim(ToString(arg));
   } else if (!arg->getType()->isCharType() &&
-             Mapper::Map(arg->getType()) != "Vec<u8>") {
+             Mapper::Map(arg->getType()) !=
+                 std::format("Vec<{}>", CharRustType())) {
     fmt += ("{:" + fmt_width + fmt_trait + "}");
     fmt_width.clear(); // Reset setw after first usage
     arg_str = ToString(arg);
@@ -1426,11 +1432,13 @@ bool Converter::GetFmtArg(clang::Expr *arg, std::string &fmt,
 
 bool Converter::GetRawArg(clang::Expr *arg, std::string &raw_args) {
   if (arg->getType()->isCharType()) {
-    raw_args += "(&[" + ToString(arg) + ']';
-  } else if (Mapper::Map(arg->getType()) == "Vec<u8>") {
+    raw_args += "(&[" + ToString(arg) + " as u8]";
+  } else if (Mapper::Map(arg->getType()) ==
+             std::format("Vec<{}>", CharRustType())) {
     PushExprKind push(*this, ExprKind::RValue);
     std::string str = ToString(arg);
-    raw_args += "(&(" + str + ")[..(" + str + ").len() - 1]";
+    raw_args += "(&(" + str + ").iter().take((" + str +
+                ").len() - 1).map(|&c| c as u8).collect::<Vec<u8>>()[..]";
   } else if (Mapper::ToString(arg).contains("std::endl")) {
     raw_args += "(&[b'\\n']";
   } else if (clang::isa<clang::StringLiteral>(arg->IgnoreImplicit())) {
@@ -1847,6 +1855,14 @@ Converter::ConvertCallExpr(clang::CallExpr *expr) {
   return std::nullopt;
 }
 
+static std::string getTypedLiteral(const char *num, std::string_view type) {
+  if (type.contains("::")) {
+    // Not a builtin type
+    return std::format("({} as {})", num, type);
+  }
+  return std::format("{}_{}", num, type);
+}
+
 std::string Converter::getIntegerLiteral(clang::IntegerLiteral *expr,
                                          bool incl_type,
                                          const clang::QualType *type) {
@@ -1868,7 +1884,7 @@ std::string Converter::getIntegerLiteral(clang::IntegerLiteral *expr,
         return init;
       }
     }
-    return std::format("{}_{}", num_as_string.c_str(), type_as_string);
+    return getTypedLiteral(num_as_string.c_str(), type_as_string);
   }
 
   return static_cast<std::string>(num_as_string);
@@ -1961,19 +1977,23 @@ bool Converter::VisitStringLiteral(clang::StringLiteral *expr) {
     if (auto *arr_ty = ctx_.getAsConstantArrayType(curr_init_type_.back())) {
       uint64_t arr_size = arr_ty->getSize().getZExtValue();
       if (expr->getString().empty()) {
-        StrCat(std::format("[0u8; {}]", arr_size));
+        StrCat(std::format("[0 as libc::c_char; {}]", arr_size));
         return false;
       }
       uint64_t pad = arr_size > expr->getString().size()
                          ? arr_size - expr->getString().size()
                          : 0;
-      StrCat(token::kStar,
-             std::format("b{}", GetEscapedStringLiteral(expr, pad)));
+      StrCat(std::format("std::mem::transmute(*b{})",
+                         GetEscapedStringLiteral(expr, pad)));
       return false;
     }
-    StrCat(token::kStar);
+    StrCat(std::format("std::mem::transmute(*b{})",
+                       GetEscapedStringLiteral(expr, 1)));
+    return false;
   }
-  StrCat(std::format("b{}", GetEscapedStringLiteral(expr, 1)));
+  assert(!expr->getString().contains('\0') &&
+         "interior null byte in string literal");
+  StrCat(std::format("c{}", GetEscapedStringLiteral(expr, 0)));
   return false;
 }
 
@@ -2056,15 +2076,6 @@ bool Converter::VisitImplicitCastExpr(clang::ImplicitCastExpr *expr) {
     }
     bool dest_pointee_const =
         expr->getType()->getPointeeType().isConstQualified();
-    if (const auto *member =
-            clang::dyn_cast<clang::MemberExpr>(sub_expr->IgnoreParenImpCasts());
-        member && IsCharArrayFieldFromLibc(member->getMemberDecl())) {
-      PushParen paren(*this);
-      Convert(sub_expr);
-      StrCat(dest_pointee_const ? ".as_ptr()" : ".as_mut_ptr()");
-      StrCat(keyword::kAs, dest_pointee_const ? "*const u8" : "*mut u8");
-      break;
-    }
     Convert(sub_expr);
     if (clang::isa<clang::StringLiteral>(sub_expr) ||
         clang::isa<clang::PredefinedExpr>(sub_expr)) {
@@ -2752,16 +2763,6 @@ bool Converter::VisitMemberExpr(clang::MemberExpr *expr) {
     return false;
   }
 
-  // char* fields in libc structs are *mut i8. We represent char* as *mut u8. Do
-  // the i8 -> u8 conversion here.
-  if (IsCharPointerFieldFromLibc(member)) {
-    StrCat(std::format("({} as {})", str,
-                       member->getType()->getPointeeType().isConstQualified()
-                           ? "*const u8"
-                           : "*mut u8"));
-    return false;
-  }
-
   StrCat(str);
   return false;
 }
@@ -3462,11 +3463,11 @@ std::string Converter::GetDefaultAsStringFallback(clang::QualType qual_type) {
   }
 
   if (qual_type->isIntegerType() && !qual_type->isEnumeralType()) {
-    return std::format("0_{}", ToString(qual_type));
+    return getTypedLiteral("0", ToString(qual_type));
   }
 
   if (qual_type->isFloatingType()) {
-    return std::format("0.0_{}", ToString(qual_type));
+    return getTypedLiteral("0.0", ToString(qual_type));
   }
 
   if (auto record = qual_type->getAsRecordDecl();
@@ -3781,7 +3782,7 @@ void Converter::ConvertFunctionMain(const clang::FunctionDecl *decl,
 pub fn main() {{
     let mut args: Vec<Vec<u8>> = std::env::args().map(|arg| arg.as_bytes().to_vec()).collect();
     args.iter_mut().for_each(|v| v.push(0));
-    let mut argv: Vec<*mut u8> = args.iter().map(|arg| arg.as_ptr() as *mut u8).collect();
+    let mut argv: Vec<*mut libc::c_char> = args.iter().map(|arg| arg.as_ptr() as *mut libc::c_char).collect();
     argv.push(::std::ptr::null_mut());
     unsafe {{
         ::std::process::exit(main_0((argv.len() - 1) as i32, argv.as_mut_ptr()) as i32)

cpp2rust/converter/converter.h

@@ -116,6 +116,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual bool EmitsReprCForRecords() const { return true; }
 
+  virtual const char *CharRustType() const { return "libc::c_char"; }
+
   virtual bool VisitCXXMethodDecl(clang::CXXMethodDecl *decl);
   virtual std::string GetSelfMaybeWithMut(const clang::CXXMethodDecl *decl);
 

cpp2rust/converter/converter_lib.cpp

@@ -130,26 +130,6 @@ bool IsInMainFile(const clang::Decl *decl) {
   return src_mgr.isInMainFile(src_mgr.getExpansionLoc(loc));
 }
 
-bool IsCharPointerFieldFromLibc(const clang::ValueDecl *decl) {
-  auto field = clang::dyn_cast<clang::FieldDecl>(decl);
-  if (!field || !field->getType()->isPointerType() ||
-      !field->getType()->getPointeeType()->isCharType()) {
-    return false;
-  }
-  return field->getASTContext().getSourceManager().isInSystemHeader(
-      field->getParent()->getLocation());
-}
-
-bool IsCharArrayFieldFromLibc(const clang::ValueDecl *decl) {
-  auto field = clang::dyn_cast<clang::FieldDecl>(decl);
-  if (!field || !field->getType()->isArrayType() ||
-      !field->getType()->getArrayElementTypeNoTypeQual()->isCharType()) {
-    return false;
-  }
-  return field->getASTContext().getSourceManager().isInSystemHeader(
-      field->getParent()->getLocation());
-}
-
 bool IsUserDefinedDecl(const clang::Decl *decl) {
   const auto &ctx = decl->getASTContext();
   const auto &src_mgr = ctx.getSourceManager();

cpp2rust/converter/converter_lib.h

@@ -40,10 +40,6 @@ bool IsComparisonWithNullOp(const clang::BinaryOperator *expr);
 
 bool IsInMainFile(const clang::Decl *decl);
 
-bool IsCharPointerFieldFromLibc(const clang::ValueDecl *decl);
-
-bool IsCharArrayFieldFromLibc(const clang::ValueDecl *decl);
-
 bool IsUserDefinedDecl(const clang::Decl *decl);
 
 bool RefersToUserDefinedDecl(const clang::Expr *expr);

cpp2rust/converter/mapper.cpp

@@ -530,7 +530,14 @@ void addBuiltinTypes(Model model) {
   }
 
   // Char
-  add_builtin_rule(ctx_->CharTy, "u8");
+  switch (model) {
+  case Model::kUnsafe:
+    add_builtin_rule(ctx_->CharTy, "libc::c_char");
+    break;
+  case Model::kRefCount:
+    add_builtin_rule(ctx_->CharTy, "u8");
+    break;
+  }
   add_builtin_rule(ctx_->SignedCharTy, "i8");
   add_builtin_rule(ctx_->UnsignedCharTy, "u8");
 

cpp2rust/converter/models/converter_refcount.cpp

@@ -211,7 +211,8 @@ std::string ConverterRefCount::BuildFnAdapter(
         closure += std::format("a{}.reinterpret_cast::<{}>()", i,
                                ConvertPointeeType(src_pty));
       } else if (src_pty->getPointeeType()->isCharType()) {
-        closure += std::format("a{}.reinterpret_cast::<u8>()", i);
+        closure += std::format("a{}.reinterpret_cast::<{}>()", i,
+                               ConvertPointeeType(src_pty));
       }
     } else {
       // UB: Incompatible types
@@ -1103,8 +1104,7 @@ bool ConverterRefCount::VisitStringLiteral(clang::StringLiteral *expr) {
                 ? arr_size - expr->getString().size()
                 : 0;
     }
-    StrCat(std::format("Box::<[u8]>::from(b{}.as_slice())",
-                       GetEscapedStringLiteral(expr, pad)));
+    StrCat(std::format("Box::from(*b{})", GetEscapedStringLiteral(expr, pad)));
     return false;
   }
   StrCat(std::format("b{}", GetEscapedStringLiteral(expr, 0)));

cpp2rust/converter/models/converter_refcount.h

@@ -32,6 +32,8 @@ class ConverterRefCount final : public Converter {
 
   bool EmitsReprCForRecords() const override { return false; }
 
+  const char *CharRustType() const override { return "u8"; }
+
   void ConvertOrdAndPartialOrdTraits(const clang::CXXRecordDecl *decl,
                                      const clang::FunctionDecl *op) override;
 

cpp2rust/cpp2rust.cpp

@@ -190,7 +190,7 @@ int main(int argc, char *argv[]) {
   file.close();
 
   // call rustfmt.
-  std::string rustfmt_command = "rustfmt " + RsFile;
+  std::string rustfmt_command = "rustfmt --edition 2024 " + RsFile;
   if (std::system(rustfmt_command.c_str()) != 0) {
     llvm::errs() << "ERROR: failed to run rustfmt\n";
     return EXIT_FAILURE;

libcc2rs/src/alloc.rs

@@ -32,6 +32,6 @@ pub unsafe fn calloc_unsafe(a0: usize, a1: usize) -> *mut libc::c_void {
 /// # Safety
 ///
 /// Same contract as C's `strdup`.
-pub unsafe fn strdup_unsafe(a0: *const u8) -> *mut u8 {
-    unsafe { libc::strdup(a0 as *const libc::c_char) as *mut u8 }
+pub unsafe fn strdup_unsafe(a0: *const libc::c_char) -> *mut libc::c_char {
+    unsafe { libc::strdup(a0) }
 }

rules/algorithm/tgt_unsafe.rs

@@ -101,7 +101,11 @@ unsafe fn f12<T1: Clone>(a0: *mut T1, a1: *mut T1, a2: T1) {
     std::slice::from_raw_parts_mut(a0, count).fill(a2)
 }
 
-unsafe fn f13(a0: *const u8, a1: *const u8, a2: &mut ::std::fs::File) -> ::std::fs::File {
+unsafe fn f13(
+    a0: *const libc::c_char,
+    a1: *const libc::c_char,
+    a2: &mut ::std::fs::File,
+) -> ::std::fs::File {
     let __start = a0 as *const u8;
     let __end = a1 as *const u8;
     let __len = __end.offset_from(__start) as usize;