Translate destructors in unsafe (#330)

Fixes #310 

Furthermore, droppable types don't implement copy.

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -348,7 +348,7 @@ bool Converter::VisitFunctionDecl(clang::FunctionDecl *decl) {
     return false;
   }
   decl->dump(log());
-  curr_function_ = decl;
+  PushCurrFunction push_fn(*this, decl);
   std::string function_name;
   if (decl->isMain()) {
     function_name = "main_0";
@@ -677,6 +677,10 @@ bool Converter::RecordDerivesCopy(const clang::RecordDecl *decl) const {
 }
 
 bool Converter::RecordHasCopyableFields(const clang::RecordDecl *decl) {
+  if (auto *cxx = clang::dyn_cast<clang::CXXRecordDecl>(decl);
+      cxx && !cxx->hasTrivialDestructor()) {
+    return false;
+  }
   for (auto f : decl->fields()) {
     // Records that contain std::vector, std::array, std::string or anything
     // that is translated to Vec<>, do not derive Copy
@@ -931,7 +935,7 @@ bool Converter::VisitCXXMethodDecl(clang::CXXMethodDecl *decl) {
   if (!decl_ids_.insert(GetMethodID(decl)).second) {
     return false;
   }
-  curr_function_ = decl;
+  PushCurrFunction push_fn(*this, decl);
 
   if (decl->isOutOfLine() && !decl->overridden_methods().empty()) {
     return false;
@@ -991,7 +995,7 @@ bool Converter::VisitCXXConstructorDecl(clang::CXXConstructorDecl *decl) {
   if (decl->isOutOfLine() || decl->isImplicit()) {
     return false;
   }
-  curr_function_ = decl;
+  PushCurrFunction push_fn(*this, decl);
 
   if (decl->isCopyOrMoveConstructor()) {
     // FIXME: improve error handling
@@ -3279,11 +3283,9 @@ bool Converter::VisitLambdaExpr(clang::LambdaExpr *expr) {
   }
   StrCat("| {");
   EmitFunctionPreamble(expr->getLambdaClass()->getLambdaCallOperator());
-  // TODO: replace with a stack
-  auto old_function = curr_function_;
-  curr_function_ = expr->getLambdaClass()->getLambdaCallOperator();
+  PushCurrFunction push_fn(*this,
+                           expr->getLambdaClass()->getLambdaCallOperator());
   ConvertFunctionBody(curr_function_);
-  curr_function_ = old_function;
   StrCat('}');
   return false;
 }
@@ -3969,7 +3971,20 @@ void Converter::AddOrdTrait(const clang::CXXRecordDecl *decl) {
 
 void Converter::AddCloneTrait(const clang::RecordDecl *decl) {}
 
-void Converter::AddDropTrait(const clang::CXXRecordDecl *decl) {}
+void Converter::AddDropTrait(const clang::CXXRecordDecl *decl) {
+  auto *dtor = GetTranslatableDestructor(decl);
+  if (!dtor) {
+    return;
+  }
+  PushCurrFunction push_fn(*this, dtor);
+  StrCat(keyword::kImpl, "Drop for", GetRecordName(decl));
+  PushBrace impl_brace(*this);
+  StrCat("fn drop(&mut self)");
+  PushBrace fn_brace(*this);
+  StrCat(keyword_unsafe_);
+  PushBrace unsafe_brace(*this);
+  ConvertBodyStmts(dtor->getDefinition()->getBody());
+}
 
 void Converter::AddDefaultTraitForUnion(const clang::RecordDecl *decl) {
   StrCat(std::format("impl Default for {}", GetRecordName(decl)));

cpp2rust/converter/converter.h

@@ -854,6 +854,16 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   void dump_expr_kinds();
 
+  struct PushCurrFunction {
+    Converter &c;
+    clang::FunctionDecl *prev;
+    PushCurrFunction(Converter &c, clang::FunctionDecl *decl)
+        : c(c), prev(c.curr_function_) {
+      c.curr_function_ = decl;
+    }
+    ~PushCurrFunction() { c.curr_function_ = prev; }
+  };
+
   struct PushExprKind {
     Converter &c;
     PushExprKind(Converter &c, ExprKind k, const char *file = __builtin_FILE(),

cpp2rust/converter/converter_lib.cpp

@@ -587,6 +587,19 @@ const char *GetOverloadedOperator(const clang::FunctionDecl *decl) {
   }
 }
 
+clang::CXXDestructorDecl *
+GetTranslatableDestructor(const clang::CXXRecordDecl *decl) {
+  if (!IsUserDefinedDecl(decl)) {
+    return nullptr;
+  }
+  auto *dtor = decl->getDestructor();
+  if (!dtor || dtor->isImplicit()) {
+    return nullptr;
+  }
+  auto *definition = dtor->getDefinition();
+  return definition && !definition->isDefaulted() ? dtor : nullptr;
+}
+
 bool IsOverloadedComparisonOperator(const clang::CXXMethodDecl *decl) {
   if (decl->isOverloadedOperator()) {
     switch (decl->getOverloadedOperator()) {

cpp2rust/converter/converter_lib.h

@@ -119,6 +119,9 @@ const char *GetOverloadedOperator(const clang::FunctionDecl *decl);
 
 bool IsOverloadedComparisonOperator(const clang::CXXMethodDecl *decl);
 
+clang::CXXDestructorDecl *
+GetTranslatableDestructor(const clang::CXXRecordDecl *decl);
+
 clang::Expr *ToAddrOf(clang::ASTContext &ctx, clang::Expr *expr);
 
 std::vector<clang::CXXRecordDecl *>

cpp2rust/converter/models/converter_refcount.cpp

@@ -586,7 +586,10 @@ void ConverterRefCount::AddDropTrait(const clang::CXXRecordDecl *decl) {
 
   StrCat(keyword::kImpl, "Drop for", record_name, '{');
   StrCat("fn drop(&mut self)");
-  ConvertBody(body);
+  {
+    PushCurrFunction push_fn(*this, dtor);
+    ConvertBody(body);
+  }
   StrCat('}');
 }
 

tests/unit/destructor.cpp

@@ -0,0 +1,86 @@
+#include <cassert>
+
+int global = 0;
+
+struct S {
+  ~S() { global++; }
+};
+
+struct Defaulted {
+  S s;
+  ~Defaulted() = default;
+};
+
+struct Middle {
+  S s;
+};
+
+struct Outer {
+  Middle m;
+};
+
+struct ArrayMember {
+  S items[3];
+};
+
+struct EmptyBody {
+  S s;
+  ~EmptyBody() {}
+};
+
+template <typename T> struct Templated {
+  T v;
+  ~Templated() { global += sizeof(T); }
+};
+
+struct Copied {
+  int v;
+  ~Copied() { global++; }
+};
+
+int main() {
+  {
+    S s{};
+  }
+  assert(global == 1);
+
+  {
+    S s{};
+  }
+  assert(global == 2);
+
+  {
+    Defaulted d{};
+  }
+  assert(global == 3);
+
+  {
+    Outer o{};
+  }
+  assert(global == 4);
+
+  {
+    ArrayMember am{};
+  }
+  assert(global == 7);
+
+  {
+    EmptyBody e{};
+  }
+  assert(global == 8);
+
+  {
+    Templated<char> tc{};
+    Templated<int> ti{};
+  }
+  assert(global == 13);
+
+  {
+    Copied a{5};
+    Copied b = a;
+    assert(b.v == 5);
+  }
+  assert(global == 15);
+
+  return 0;
+}