Merge branch 'master' into 18-union-list-init

Author: lucic71

CMakeLists.txt

@@ -90,7 +90,7 @@ find_program(CLANG_FORMAT NAMES clang-format-22 clang-format)
 find_program(RUFF NAMES ruff)
 
 file(GLOB_RECURSE ALL_CXX_SOURCES
-     cpp2rust/*.cpp cpp2rust/*.h tests/*.cpp tests/*.c)
+     cpp2rust/*.cpp cpp2rust/*.h rules/*.cpp rules/*.c rules/*.h tests/*.cpp tests/*.c)
 
 set(PYTHON_SOURCES ${PROJECT_SOURCE_DIR}/tests/lit/lit/formats/Cpp2RustTest.py)
 

cpp2rust/converter/converter.cpp

@@ -30,7 +30,6 @@ std::unordered_map<std::string, std::string> Converter::inner_structs_;
 std::unordered_set<std::string> Converter::decl_ids_;
 std::unordered_set<std::string> Converter::globals_;
 std::vector<std::string> Converter::global_inits_;
-std::unordered_set<std::string> Converter::abstract_structs_;
 Converter::RecordIndex Converter::record_decls_;
 std::map<std::string, Converter::DeferredBlock> Converter::virtual_methods_;
 
@@ -318,7 +317,7 @@ bool Converter::VisitPointerType(clang::PointerType *type) {
   auto pointee_type = type->getPointeeType();
   StrCat(pointee_type.isConstQualified() ? "*const" : "*mut");
   if (pointee_type->isRecordType() &&
-      abstract_structs_.contains(GetID(pointee_type->getAsRecordDecl()))) {
+      IsAbstractUserClass(pointee_type->getAsRecordDecl())) {
     StrCat(keyword::kDyn);
   }
   return Convert(pointee_type);
@@ -1364,7 +1363,11 @@ bool Converter::VisitDeclStmt(clang::DeclStmt *stmt) {
       hoisted_records_ += std::move(buf).str();
       continue;
     }
-    Convert(decl);
+    if (var && var->isImplicit()) {
+      VisitVarDecl(var);
+    } else {
+      Convert(decl);
+    }
     StrCat(token::kSemiColon);
   }
   return false;
@@ -2279,8 +2282,13 @@ std::optional<Converter::TempMaterializationCtx>
 Converter::ConvertCallExpr(clang::CallExpr *expr) {
   auto *callee = expr->getCallee();
 
-  if (auto fn = Printer::ToString(ctx_, callee);
-      fn.starts_with("int printf") || fn.starts_with("int fprintf")) {
+  auto fn = Printer::ToString(ctx_, callee);
+  bool is_printf = fn.starts_with("int printf");
+  bool is_fprintf = fn.starts_with("int fprintf");
+  unsigned format_arg = is_fprintf ? 1 : 0;
+  if ((is_printf || is_fprintf) &&
+      clang::isa<clang::StringLiteral>(
+          expr->getArg(format_arg)->IgnoreImplicit())) {
     ConvertPrintf(expr);
   } else if (IsTransparentStdCall(expr)) {
     Convert(expr->getArg(0));
@@ -4637,7 +4645,6 @@ pub fn main() {{
 }
 
 void Converter::ConvertAbstractClass(clang::CXXRecordDecl *decl) {
-  ENSURE(abstract_structs_.insert(GetID(decl)).second);
   auto trait_name = GetRecordName(decl);
   auto access_specifier_as_string = AccessSpecifierAsString(decl->getAccess());
   auto signature = std::format("{} {} trait {}", access_specifier_as_string,

cpp2rust/converter/converter.h

@@ -952,7 +952,6 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   };
 
   static std::unordered_set<std::string> decl_ids_;
-  static std::unordered_set<std::string> abstract_structs_;
 
   class RecordIndex {
   public:

cpp2rust/converter/converter_lib.cpp

@@ -75,6 +75,7 @@ static const char rust_keywords[][12] = {
     "safe",
     // Standard library keywords
     "vec",
+    "Err",
 };
 
 namespace cpp2rust {
@@ -301,6 +302,13 @@ bool IsUserDefinedDecl(const clang::Decl *decl) {
          !src_mgr.isInSystemMacro(src_loc);
 }
 
+bool IsAbstractUserClass(const clang::RecordDecl *decl) {
+  auto cxx = llvm::dyn_cast<clang::CXXRecordDecl>(decl);
+  auto definition = cxx ? cxx->getDefinition() : nullptr;
+  return definition && IsUserDefinedDecl(definition) &&
+         definition->isAbstract();
+}
+
 bool RefersToUserDefinedDecl(const clang::Expr *expr) {
   expr = expr->IgnoreParenImpCasts();
   const clang::Decl *decl = nullptr;
@@ -912,6 +920,23 @@ static size_t GetDeclId(const clang::NamedDecl *decl, bool internal) {
   return type_mapping.try_emplace(key, type_mapping.size()).first->second;
 }
 
+void EscapeRustKeyword(std::string &name) {
+  if (!name.empty() &&
+      std::ranges::all_of(name, [](char c) { return c == '_'; })) {
+    name += '_';
+  }
+  for (auto &keyword : rust_keywords) {
+    if (!name.starts_with(keyword))
+      continue;
+
+    auto suffix = std::string_view(name).substr(strlen(keyword));
+    if (std::ranges::all_of(suffix, [](char c) { return c == '_'; })) {
+      name += '_';
+      break;
+    }
+  }
+}
+
 std::string GetNamedDeclAsString(const clang::NamedDecl *decl) {
   auto name = decl->getDeclName().isIdentifier() ? decl->getName().str()
                                                  : decl->getNameAsString();
@@ -927,13 +952,24 @@ std::string GetNamedDeclAsString(const clang::NamedDecl *decl) {
     }
   }
 
+  auto *anonymous_record_var = clang::dyn_cast<clang::VarDecl>(decl);
+  if (anonymous_record_var) {
+    auto *record = anonymous_record_var->getType()->getAsRecordDecl();
+    if (clang::isa<clang::ParmVarDecl>(decl) || !record ||
+        record->getIdentifier()) {
+      anonymous_record_var = nullptr;
+    }
+  }
+
   // Anonymous record or enum
-  if (name.empty() && (clang::isa<clang::RecordDecl>(decl) ||
-                       clang::isa<clang::FieldDecl>(decl) ||
-                       clang::isa<clang::EnumDecl>(decl))) {
+  if (name.empty() &&
+      (clang::isa<clang::RecordDecl>(decl) ||
+       clang::isa<clang::FieldDecl>(decl) || anonymous_record_var ||
+       clang::isa<clang::EnumDecl>(decl))) {
     const clang::NamedDecl *target = decl;
-    if (auto *field = clang::dyn_cast<clang::FieldDecl>(decl)) {
-      if (auto *record = field->getType()->getAsRecordDecl();
+    if (clang::isa<clang::FieldDecl, clang::VarDecl>(decl)) {
+      auto type = clang::cast<clang::ValueDecl>(decl)->getType();
+      if (auto *record = type->getAsRecordDecl();
           record && !record->getIdentifier()) {
         target = record;
       }
@@ -962,24 +998,7 @@ std::string GetNamedDeclAsString(const clang::NamedDecl *decl) {
     name += std::to_string(*id);
   }
 
-  // transform decl names that are rust keywords:
-  // keyword -> keyword_
-  // keyword_ -> keyword__
-  // etc
-  if (!name.empty() &&
-      std::ranges::all_of(name, [](char c) { return c == '_'; })) {
-    name += '_';
-  }
-  for (auto &keyword : rust_keywords) {
-    if (!name.starts_with(keyword))
-      continue;
-
-    auto suffix = std::string_view(name).substr(strlen(keyword));
-    if (std::ranges::all_of(suffix, [](char c) { return c == '_'; })) {
-      name += '_';
-      break;
-    }
-  }
+  EscapeRustKeyword(name);
 
   if (name.empty()) {
     auto *pdecl = llvm::dyn_cast<clang::ParmVarDecl>(decl);

cpp2rust/converter/converter_lib.h

@@ -66,6 +66,8 @@ bool IsCodeUnitStringLiteral(const clang::StringLiteral *expr);
 
 bool IsUserDefinedDecl(const clang::Decl *decl);
 
+bool IsAbstractUserClass(const clang::RecordDecl *decl);
+
 bool RefersToUserDefinedDecl(const clang::Expr *expr);
 
 bool IsUnsignedArithOp(const clang::BinaryOperator *expr);
@@ -180,6 +182,8 @@ unsigned GetArraySize(clang::QualType array_type);
 std::string GetID(const clang::Decl *decl);
 std::string GetMethodID(const clang::CXXMethodDecl *decl);
 
+void EscapeRustKeyword(std::string &name);
+
 std::string GetNamedDeclAsString(const clang::NamedDecl *decl);
 
 std::string DisambiguateAnonymousTag(const clang::TagDecl *tag);

cpp2rust/converter/models/converter_refcount.cpp

@@ -341,7 +341,7 @@ bool ConverterRefCount::VisitPointerType(clang::PointerType *type) {
   PushConversionKind push2(*this, ConversionKind::FullRefCount,
                            pointee_is_array);
   if (pointee_type->isRecordType() &&
-      abstract_structs_.contains(GetID(pointee_type->getAsRecordDecl()))) {
+      IsAbstractUserClass(pointee_type->getAsRecordDecl())) {
     StrCat("PtrDyn<dyn");
   } else {
     StrCat("Ptr<");
@@ -1252,16 +1252,8 @@ static std::vector<const char *> printf2fmt(std::string &format) {
 void ConverterRefCount::ConvertPrintf(clang::CallExpr *expr) {
   bool is_fprintf =
       Printer::ToString(ctx_, expr->getCallee()).starts_with("int fprintf");
-  std::string format;
-  if (auto *str = clang::dyn_cast<clang::StringLiteral>(
-          expr->getArg(is_fprintf)->IgnoreImplicit())) {
-    format = GetEscapedStringLiteral(str);
-  } else {
-    llvm::errs() << "Unknown fprintf format: ";
-    expr->getArg(1)->dump();
-    llvm::errs() << '\n';
-    exit(1);
-  }
+  auto format = GetEscapedStringLiteral(clang::cast<clang::StringLiteral>(
+      expr->getArg(is_fprintf)->IgnoreImplicit()));
   bool ends_newline = format.ends_with("\\n\"");
 
   auto fd = is_fprintf ? Printer::ToString(ctx_, expr->getArg(0)) : "stdout";
@@ -1507,7 +1499,7 @@ bool ConverterRefCount::VisitImplicitCastExpr(clang::ImplicitCastExpr *expr) {
       auto ptype = clang::dyn_cast<clang::PointerType>(expr->getType());
       auto pointee_type = ptype->getPointeeType()->getAsCXXRecordDecl();
 
-      if (pointee_type && abstract_structs_.contains(GetID(pointee_type))) {
+      if (pointee_type && IsAbstractUserClass(pointee_type)) {
         PushConversionKind push(*this, ConversionKind::Unboxed);
         StrCat(std::format("{}.to_dyn::<{}>(|w| w)",
                            ToString(sub_expr->IgnoreCasts()),
@@ -3237,7 +3229,7 @@ void ConverterRefCount::ConvertArrow(clang::Expr *expr) {
     auto pointee_type = expr->getType()->getPointeeType();
     // Virtual methods, which take &mut self, are called through PtrDyn.
     if (auto *record = pointee_type->getAsRecordDecl();
-        isLValue() && record && abstract_structs_.contains(GetID(record))) {
+        isLValue() && record && IsAbstractUserClass(record)) {
       StrCat(std::format("(*{}.upgrade().deref_mut())", ToString(expr)));
       SetValueFreshness(pointee_type);
       return;

cpp2rust/converter/printer.cpp

@@ -116,6 +116,7 @@ std::string ToRustName(std::string name) {
   if (stem == "Ptr" || stem == "Value" || stem == "Box") {
     name += '_';
   }
+  EscapeRustKeyword(name);
   return name;
 }
 

rules/algorithm/src.cpp

@@ -19,8 +19,7 @@ template <class T1, class T2> T1 f3(T1 first, T1 last, const T2 &value) {
   return std::find(first, last, value);
 }
 
-template <typename T1, typename T2>
-void f6(T1 first, T1 last, T2 comp) {
+template <typename T1, typename T2> void f6(T1 first, T1 last, T2 comp) {
   return std::stable_sort(first, last, comp);
 }
 
@@ -48,8 +47,7 @@ std::ostream_iterator<char> f13(std::string::iterator a0,
   return std::copy(a0, a1, a2);
 }
 
-template <typename T1, typename T2>
-void f14(T1 *first, T1 *last, T2 comp) {
+template <typename T1, typename T2> void f14(T1 *first, T1 *last, T2 comp) {
   return std::stable_sort(first, last, comp);
 }
 

rules/array/src.cpp

@@ -3,8 +3,7 @@
 
 #include <array>
 
-template <typename T1, std::size_t T2>
-using t1 = std::array<T1, T2>;
+template <typename T1, std::size_t T2> using t1 = std::array<T1, T2>;
 
 template <typename T1, std::size_t T2>
 using t2 = typename std::array<T1, T2>::size_type;

rules/assert/src.c

@@ -3,6 +3,4 @@
 
 #include <assert.h>
 
-bool f1(bool condition) {
-  return cpp2rust_assert_fail(condition);
-}
+bool f1(bool condition) { return cpp2rust_assert_fail(condition); }