Merge branch 'master' into variadic-call

Author: lucic71

README.md

@@ -60,7 +60,7 @@ ninja check
 ./build/cpp2rust/cpp2rust --file=<file>.cpp -o=<file>.rs
 ```
 
-By default, the reference couting model is used (fully safe output).
+By default, the reference counting model is used (fully safe output).
 To generate unsafe Rust instead:
 
 ```bash
@@ -128,7 +128,7 @@ ninja check-unit
 ninja check-libcc2rs
 
 # Run libcc2rs-macros unit tests
-ninja check-benchmarks
+ninja check-libcc2rs-macros
 
 # Regenerate expected output for unit tests after intentional changes
 REPLACE_EXPECTED=1 ninja check-unit

cmake/rust-toolchain.cmake

@@ -1,2 +1,2 @@
-set(RUST_STABLE_VERSION "1.96.0")
-set(RUST_NIGHTLY_VERSION "nightly-2026-06-02")
+set(RUST_STABLE_VERSION "1.96.1")
+set(RUST_NIGHTLY_VERSION "nightly-2026-06-30")

cpp2rust/CMakeLists.txt

@@ -24,6 +24,7 @@ target_compile_definitions(cpp2rust_core PUBLIC "-DCLANG_C_COMPILER=\"${CMAKE_C_
 target_compile_definitions(cpp2rust_core PUBLIC "-DCLANG_CXX_COMPILER=\"${CMAKE_CXX_COMPILER}\"")
 target_compile_definitions(cpp2rust_core PUBLIC "-DCLANG_RESOURCE_DIR=\"${LLVM_LIBRARY_DIR}/clang/${LLVM_VERSION_MAJOR}\"")
 target_compile_definitions(cpp2rust_core PUBLIC "-DCOMPAT_INCLUDE_DIR=\"${CMAKE_CURRENT_SOURCE_DIR}/compat\"")
+target_compile_definitions(cpp2rust_core PUBLIC "-DRUST_STABLE_VERSION=\"${RUST_STABLE_VERSION}\"")
 
 if (APPLE)
   execute_process(

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:
@@ -753,6 +758,11 @@ void Converter::EmitRustStructOrUnion(clang::RecordDecl *decl) {
     }
   }
 
+  if (decl->isUnion()) {
+    EmitRustUnion(decl);
+    return;
+  }
+
   // Derived traits
   if (EmitsReprCForRecords()) {
     StrCat("#[repr(C)]");
@@ -770,8 +780,7 @@ void Converter::EmitRustStructOrUnion(clang::RecordDecl *decl) {
   auto access = clang::dyn_cast<clang::CXXRecordDecl>(decl)
                     ? AccessSpecifierAsString(decl->getAccess())
                     : keyword::kPub;
-  StrCat(access, decl->isUnion() ? keyword::kUnion : keyword::kStruct,
-         GetRecordName(decl));
+  StrCat(access, keyword::kStruct, GetRecordName(decl));
   {
     PushBrace brace(*this);
     for (auto *field : decl->fields()) {
@@ -810,9 +819,32 @@ void Converter::EmitRustStructOrUnion(clang::RecordDecl *decl) {
   // Traits
   if (auto *cxx = clang::dyn_cast<clang::CXXRecordDecl>(decl)) {
     AddOrdTrait(cxx);
-    AddCloneTrait(cxx);
     AddDropTrait(cxx);
   }
+  AddCloneTrait(decl);
+  AddDefaultTrait(decl);
+  AddByteReprTrait(decl);
+}
+
+void Converter::EmitRustUnion(clang::RecordDecl *decl) {
+  StrCat("#[repr(C)]");
+  auto attrs = GetStructAttributes(decl);
+  Mapper::SetDerives(ctx_.getCanonicalTagType(decl),
+                     std::vector<std::string>(attrs.begin(), attrs.end()));
+  StrCat("#[derive(");
+  for (auto *attr : attrs) {
+    StrCat(attr, ',');
+  }
+  StrCat(")]");
+
+  StrCat(keyword::kPub, keyword::kUnion, GetRecordName(decl));
+  {
+    PushBrace brace(*this);
+    for (auto *field : decl->fields()) {
+      VisitFieldDecl(field);
+    }
+  }
+
   AddDefaultTrait(decl);
   AddByteReprTrait(decl);
 }
@@ -1383,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);
@@ -1399,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())) {
@@ -1688,6 +1723,24 @@ Converter::CallInfo Converter::CollectCallInfo(clang::CallExpr *expr) {
     }
   }
 
+  // Inline arguments that don't alias
+  clang::Expr *receiver = GetCallObject(expr);
+  for (auto &ca : info.args) {
+    if (ca.kind != Kind::Hoisted) {
+      continue;
+    }
+    bool aliases = receiver && ArgsMayAlias(ca.expr, receiver);
+    for (const auto &other : info.args) {
+      if (&other != &ca && ArgsMayAlias(ca.expr, other.expr)) {
+        aliases = true;
+        break;
+      }
+    }
+    if (!aliases) {
+      ca.kind = Kind::Inline;
+    }
+  }
+
   return info;
 }
 
@@ -1824,6 +1877,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) {
@@ -1845,7 +1906,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);
@@ -1938,19 +1999,30 @@ 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;
+  }
+  if (expr->getString().contains('\0')) {
+    std::string out = "(&[";
+    for (unsigned char c : expr->getString()) {
+      out += getTypedLiteral(std::to_string(c).c_str(), CharRustType()) + ", ";
+    }
+    out += getTypedLiteral("0", CharRustType()) + "])";
+    StrCat(out);
+    return false;
   }
-  StrCat(std::format("b{}", GetEscapedStringLiteral(expr, 1)));
+  StrCat(std::format("c{}", GetEscapedStringLiteral(expr, 0)));
   return false;
 }
 
@@ -2033,15 +2105,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)) {
@@ -2233,7 +2296,8 @@ void Converter::ConvertBinaryOperator(clang::BinaryOperator *expr) {
   if (auto *cmpd_assign_op =
           llvm::dyn_cast<clang::CompoundAssignOperator>(expr);
       expr->isCompoundAssignmentOp() &&
-      lhs_type != cmpd_assign_op->getComputationResultType()) {
+      GetUnsafeTypeAsString(lhs_type) !=
+          GetUnsafeTypeAsString(cmpd_assign_op->getComputationResultType())) {
     auto computation_result_type = cmpd_assign_op->getComputationResultType();
     if (IsUnsignedArithOp(cmpd_assign_op)) {
       Convert(lhs);
@@ -2257,7 +2321,7 @@ void Converter::ConvertBinaryOperator(clang::BinaryOperator *expr) {
       auto op = opcode_as_string;
       op.remove_suffix(1); // remove '=' from operator
       StrCat(op);
-      Convert(rhs);
+      Convert(rhs, computation_result_type);
     }
     if (lhs_type->isBooleanType()) {
       StrCat(token::kDiff, token::kZero);
@@ -2729,16 +2793,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;
 }
@@ -2903,7 +2957,8 @@ bool Converter::VisitCompoundLiteralExpr(clang::CompoundLiteralExpr *expr) {
 
 bool Converter::VisitArraySubscriptExpr(clang::ArraySubscriptExpr *expr) {
   auto *base = expr->getBase();
-  if (base->IgnoreCasts()->getType()->isPointerType()) {
+  if (base->IgnoreCasts()->getType()->isPointerType() ||
+      clang::isa<clang::StringLiteral>(base->IgnoreCasts())) {
     ConvertPointerSubscript(expr);
   } else {
     ConvertArraySubscript(base, expr->getIdx(), expr->getType());
@@ -3158,6 +3213,7 @@ bool Converter::VisitEnumDecl(clang::EnumDecl *decl) {
 
   AddFromImpl(decl);
   AddIncDecImpls(decl);
+  AddByteReprTrait(decl);
   return false;
 }
 
@@ -3438,11 +3494,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();
@@ -3757,7 +3813,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)
@@ -3881,7 +3937,7 @@ void Converter::AddOrdTrait(const clang::CXXRecordDecl *decl) {
   ConvertOrdAndPartialOrdTraits(decl, methods[0]);
 }
 
-void Converter::AddCloneTrait(const clang::CXXRecordDecl *decl) {}
+void Converter::AddCloneTrait(const clang::RecordDecl *decl) {}
 
 void Converter::AddDropTrait(const clang::CXXRecordDecl *decl) {}
 
@@ -3940,6 +3996,8 @@ void Converter::EmitDefaultStructLiteral(const clang::RecordDecl *decl) {
 
 void Converter::AddByteReprTrait(const clang::RecordDecl *decl) {}
 
+void Converter::AddByteReprTrait(const clang::EnumDecl *decl) {}
+
 void Converter::ConvertUnsignedArithBinaryOperator(clang::BinaryOperator *op,
                                                    clang::Expr *expr) {
   StrCat(token::kDot);

cpp2rust/converter/converter.h

@@ -112,8 +112,12 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual void EmitRustStructOrUnion(clang::RecordDecl *decl);
 
+  virtual void EmitRustUnion(clang::RecordDecl *decl);
+
   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);
 
@@ -528,7 +532,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
                                          std::string_view second_return,
                                          std::string_view record_name);
 
-  virtual void AddCloneTrait(const clang::CXXRecordDecl *decl);
+  virtual void AddCloneTrait(const clang::RecordDecl *decl);
 
   virtual void AddDropTrait(const clang::CXXRecordDecl *decl);
 
@@ -540,6 +544,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual void AddByteReprTrait(const clang::RecordDecl *decl);
 
+  virtual void AddByteReprTrait(const clang::EnumDecl *decl);
+
   virtual void
   ConvertUnsignedArithBinaryOperator(clang::BinaryOperator *binary_operator,
                                      clang::Expr *expr);