Translate user defined moves

cpp2rust/converter/converter.cpp

@@ -253,6 +253,10 @@ Converter::ConvertRValue(clang::Expr *expr,
 std::string Converter::ConvertFreshRValue(
     clang::Expr *expr, std::optional<clang::QualType> implicit_convert_to) {
   auto str = ConvertRValue(expr, implicit_convert_to);
+  // TODO: set freshness correctly to avoid stale computed_expr_type_
+  if (expr->isGLValue()) {
+    SetValueFreshness(expr->getType());
+  }
   if (!isFresh() && !expr->getType()->isVoidType() &&
       !expr->getType()->isPointerType()) {
     SetFresh();
@@ -948,8 +952,9 @@ bool Converter::VisitCXXRecordDecl(clang::CXXRecordDecl *decl) {
     }
 
     if (!record_decls_.MarkDefined(GetRecordName(decl))) {
-      // Other translation units may instantiate members this one did not.
-      if (clang::isa<clang::ClassTemplateSpecializationDecl>(decl)) {
+      // Other translation units may instantiate or synthesize members this
+      // one did not.
+      if (!decl->isAbstract()) {
         ConvertLateInstantiatedMethods(decl);
       }
       return false;
@@ -960,25 +965,7 @@ bool Converter::VisitCXXRecordDecl(clang::CXXRecordDecl *decl) {
       return false;
     }
 
-    sema_->ForceDeclarationOfImplicitMembers(decl);
-    for (auto ctor : decl->ctors()) {
-      if (ctor->isCopyConstructor() && ctor->isImplicit() &&
-          !ctor->doesThisDeclarationHaveABody() && !ctor->isDeleted()) {
-        sema_->DefineImplicitCopyConstructor(decl->getLocation(), ctor);
-      }
-    }
-    for (auto *method : decl->methods()) {
-      if (IsComparisonOperator(method) && method->isDefaulted() &&
-          !method->doesThisDeclarationHaveABody()) {
-#if CLANG_VERSION_MAJOR >= 24
-        auto kind = method->getDefaultedComparisonKind();
-#else
-        auto kind = sema_->getDefaultedComparisonKind(method);
-#endif
-        sema_->DefineDefaultedComparison(decl->getLocation(), method, kind);
-      }
-    }
-
+    DefineImplicitMembers(decl);
     EmitRustStructOrUnion(decl);
   } else if (decl->isUnion()) {
     if (!record_decls_.MarkDefined(GetRecordName(decl))) {
@@ -993,6 +980,27 @@ bool Converter::VisitCXXRecordDecl(clang::CXXRecordDecl *decl) {
   return false;
 }
 
+void Converter::DefineImplicitMembers(clang::CXXRecordDecl *decl) {
+  sema_->ForceDeclarationOfImplicitMembers(decl);
+  for (auto ctor : decl->ctors()) {
+    if (ctor->isCopyConstructor() && ctor->isImplicit() &&
+        !ctor->doesThisDeclarationHaveABody() && !ctor->isDeleted()) {
+      sema_->DefineImplicitCopyConstructor(decl->getLocation(), ctor);
+    }
+  }
+  for (auto *method : decl->methods()) {
+    if (IsComparisonOperator(method) && method->isDefaulted() &&
+        !method->doesThisDeclarationHaveABody()) {
+#if CLANG_VERSION_MAJOR >= 24
+      auto kind = method->getDefaultedComparisonKind();
+#else
+      auto kind = sema_->getDefaultedComparisonKind(method);
+#endif
+      sema_->DefineDefaultedComparison(decl->getLocation(), method, kind);
+    }
+  }
+}
+
 bool Converter::VisitCXXMethodDecl(clang::CXXMethodDecl *decl) {
   decl->dump(log());
   if (!ShouldConvertMethod(decl)) {
@@ -1080,7 +1088,8 @@ std::string Converter::GetCtorName(clang::CXXConstructorDecl *decl) {
 }
 
 bool Converter::VisitCXXConstructorDecl(clang::CXXConstructorDecl *decl) {
-  if (decl->isOutOfLine() || decl->isImplicit()) {
+  if (decl->isOutOfLine() ||
+      (decl->isImplicit() && !IsUserDefinedMoveConstructorOrAssignment(decl))) {
     return false;
   }
   PushCurrFunction push_fn(*this, decl);
@@ -2660,7 +2669,7 @@ void Converter::ConvertGenericBinaryOperator(clang::BinaryOperator *expr) {
 }
 
 bool Converter::IsReferenceType(const clang::Expr *expr) const {
-  const auto *e = expr->IgnoreCasts();
+  const auto *e = IgnoreStdMove(expr->IgnoreCasts())->IgnoreCasts();
   if (const auto *call = clang::dyn_cast<clang::CallExpr>(e)) {
     return !clang::isa<clang::CXXOperatorCallExpr>(call) &&
            GetReturnTypeOfFunction(call)->isReferenceType();
@@ -3411,22 +3420,12 @@ bool Converter::VisitCXXConstructExpr(clang::CXXConstructExpr *expr) {
   }
 
   auto *ctor = expr->getConstructor();
-  // Default move is translated using a bitwise .clone() implementation.
-  // Bitwise clone is only satisfied by default copy constructor. If the copy
-  // constructor is user defined, then default move calls copy constructor,
-  // which is wrong.
-  if (IsDefaultedMoveConstructor(ctor) &&
-      !HasDefaultedCopyConstructor(ctor->getParent())) {
-    llvm::report_fatal_error("defaulted move constructor without a fieldwise "
-                             "copy constructor is not supported");
-  }
-
   if (IsPassThroughConstructor(ctor)) {
     // Take suppress before recursing into the child.
     bool suppress = PushSuppressIteratorClone::take(*this);
     Convert(expr->getArg(0));
-    if ((ctor->isCopyConstructor() || IsDefaultedMoveConstructor(ctor)) &&
-        !suppress && !TypeIsCopyable(expr->getType())) {
+    if (ctor->isCopyConstructor() && !suppress &&
+        !TypeIsCopyable(expr->getType())) {
       StrCat(".clone()");
     }
     return false;
@@ -3438,7 +3437,7 @@ bool Converter::VisitCXXConstructExpr(clang::CXXConstructExpr *expr) {
     return false;
   }
 
-  assert(ctor->isUserProvided());
+  assert(ctor->isUserProvided() || IsUserDefinedMoveConstructor(ctor));
   if (expr->getType()->isArrayType()) {
     ConvertArrayCXXConstructExpr(expr);
   } else {
@@ -3843,6 +3842,10 @@ std::string Converter::ConvertVarDefaultInit(clang::QualType qual_type) {
 std::string
 Converter::GetOverloadedFunctionName(const clang::FunctionDecl *decl) {
   auto name = GetFunctionBaseName(decl);
+  if (auto *ctor = clang::dyn_cast<clang::CXXConstructorDecl>(decl);
+      ctor && !ctor->getParent()->getIdentifier()) {
+    name = GetRecordName(ctor->getParent());
+  }
 
   if (decl->getNumParams() != 0U) {
     name += '_';

cpp2rust/converter/converter.h

@@ -331,6 +331,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual void ConvertVariadicArg(clang::Expr *arg);
 
+  void DefineImplicitMembers(clang::CXXRecordDecl *decl);
+
   virtual bool VisitCallExpr(clang::CallExpr *expr);
 
   virtual bool VisitIntegerLiteral(clang::IntegerLiteral *expr);
@@ -996,8 +998,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   virtual bool emplace_back_plugin_convert(clang::CallExpr *call);
   virtual void emplace_back_plugin_construct_arg(clang::QualType elem_type,
                                                  clang::CXXConstructExpr *ctor);
-  virtual void emplace_back_emit_push_open(clang::CXXMemberCallExpr *call);
-  virtual void emplace_back_emit_push_close(clang::CXXMemberCallExpr *call);
+  virtual void emplace_back_emit_push(clang::CXXMemberCallExpr *call,
+                                      std::string_view arg);
 
   virtual const char *GetPointerDerefPrefix(clang::QualType pointee_type);
 

cpp2rust/converter/converter_lib.cpp

@@ -286,21 +286,32 @@ bool IsUserDefinedCopyConstructor(const clang::CXXConstructorDecl *ctor) {
          IsUserDefinedDecl(ctor);
 }
 
+static bool IsTranslatedMoveMember(const clang::CXXMethodDecl *method) {
+  return !method->isDeleted() && IsUserDefinedDecl(method->getParent()) &&
+         method->hasBody();
+}
+
 bool IsUserDefinedMoveConstructor(const clang::CXXConstructorDecl *ctor) {
-  return ctor->isMoveConstructor() && ctor->isUserProvided() &&
-         IsUserDefinedDecl(ctor);
+  return ctor->isMoveConstructor() && IsTranslatedMoveMember(ctor);
+}
+
+bool IsUserDefinedMoveAssignment(const clang::CXXMethodDecl *method) {
+  return method->isMoveAssignmentOperator() && IsTranslatedMoveMember(method);
+}
+
+bool IsUserDefinedMoveConstructorOrAssignment(
+    const clang::CXXMethodDecl *method) {
+  if (auto *ctor = clang::dyn_cast<clang::CXXConstructorDecl>(method)) {
+    return IsUserDefinedMoveConstructor(ctor);
+  }
+  return IsUserDefinedMoveAssignment(method);
 }
 
 bool IsUserDefinedCopyOrMoveConstructor(const clang::CXXConstructorDecl *ctor) {
   return IsUserDefinedCopyConstructor(ctor) ||
          IsUserDefinedMoveConstructor(ctor);
 }
 
-bool IsDefaultedMoveConstructor(const clang::CXXConstructorDecl *ctor) {
-  return ctor->isMoveConstructor() && !ctor->isUserProvided() &&
-         IsUserDefinedDecl(ctor->getParent());
-}
-
 clang::CXXConstructorDecl *
 GetUserDefinedCopyConstructor(const clang::RecordDecl *decl) {
   auto *cxx = clang::dyn_cast<clang::CXXRecordDecl>(decl);
@@ -375,7 +386,8 @@ bool IsConvertibleCXXMethodDecl(const clang::CXXMethodDecl *decl) {
   if (llvm::isa<clang::CXXDestructorDecl>(decl)) {
     return GetUserDefinedDestructor(decl->getParent()) != nullptr;
   }
-  return !decl->isImplicit() || IsComparisonOperator(decl);
+  return !decl->isImplicit() || IsComparisonOperator(decl) ||
+         IsUserDefinedMoveConstructorOrAssignment(decl);
 }
 
 bool IsConvertibleFunctionDecl(const clang::FunctionDecl *decl) {
@@ -814,6 +826,10 @@ bool IsUserOperatorCall(const clang::CXXOperatorCallExpr *expr) {
       method && method->isDefaulted() && IsComparisonOperator(method)) {
     return IsUserDefinedDecl(method->getParent());
   }
+  if (const auto *method = clang::dyn_cast<clang::CXXMethodDecl>(callee);
+      method && IsUserDefinedMoveConstructorOrAssignment(method)) {
+    return true;
+  }
   if (!callee->isUserProvided() || !IsUserDefinedDecl(callee)) {
     return false;
   }
@@ -904,6 +920,9 @@ bool IsEmittableMethod(clang::CXXMethodDecl *method) {
   if (IsComparisonOperator(method)) {
     return method->hasBody();
   }
+  if (IsUserDefinedMoveConstructorOrAssignment(method)) {
+    return method->hasBody();
+  }
   // Compiler-generated members are covered by derived traits
   if (method->isImplicit()) {
     return false;
@@ -921,6 +940,9 @@ bool IsMethodOnPtr(const clang::CXXMethodDecl *method) {
       clang::isa<clang::CXXConstructorDecl>(method)) {
     return false;
   }
+  if (IsUserDefinedMoveConstructorOrAssignment(method)) {
+    return method->hasBody();
+  }
   if (method->isImplicit() && !IsComparisonOperator(method)) {
     return false;
   }
@@ -1310,6 +1332,23 @@ bool IsBuiltinVaCopy(const clang::CallExpr *expr) {
   return false;
 }
 
+const clang::Expr *IgnoreStdMove(const clang::Expr *expr) {
+  if (const auto *call =
+          clang::dyn_cast<clang::CallExpr>(expr->IgnoreParenImpCasts());
+      call && call->isCallToStdMove()) {
+    return call->getArg(0);
+  }
+  return expr;
+}
+
+bool IsTemporaryObject(const clang::Expr *expr) {
+  const auto *operand = IgnoreStdMove(expr);
+  if (operand != expr) {
+    return !operand->isGLValue();
+  }
+  return !expr->isLValue();
+}
+
 bool ContainsVAArgExpr(const clang::Stmt *stmt) {
   if (clang::isa<clang::VAArgExpr>(stmt)) {
     return true;

cpp2rust/converter/converter_lib.h

@@ -74,7 +74,10 @@ bool IsUserDefinedMoveConstructor(const clang::CXXConstructorDecl *ctor);
 
 bool IsUserDefinedCopyOrMoveConstructor(const clang::CXXConstructorDecl *ctor);
 
-bool IsDefaultedMoveConstructor(const clang::CXXConstructorDecl *ctor);
+bool IsUserDefinedMoveAssignment(const clang::CXXMethodDecl *method);
+
+bool IsUserDefinedMoveConstructorOrAssignment(
+    const clang::CXXMethodDecl *method);
 
 clang::CXXConstructorDecl *
 GetUserDefinedCopyConstructor(const clang::RecordDecl *decl);
@@ -240,6 +243,10 @@ bool IsBuiltinVaEnd(const clang::CallExpr *expr);
 
 bool IsBuiltinVaCopy(const clang::CallExpr *expr);
 
+const clang::Expr *IgnoreStdMove(const clang::Expr *expr);
+
+bool IsTemporaryObject(const clang::Expr *expr);
+
 bool ContainsVAArgExpr(const clang::Stmt *stmt);
 
 clang::Expr *NormalizeToBool(clang::Expr *expr, clang::ASTContext &ctx);

cpp2rust/converter/models/converter_refcount.cpp

@@ -1892,17 +1892,7 @@ bool ConverterRefCount::VisitCXXConstructExpr(clang::CXXConstructExpr *expr) {
     return false;
   }
 
-  // Default move is translated using a bitwise .clone() implementation.
-  // Bitwise clone is only satisfied by default copy constructor. If the copy
-  // constructor is user defined, then default move calls copy constructor,
-  // which is wrong.
-  if (IsDefaultedMoveConstructor(ctor) &&
-      !HasDefaultedCopyConstructor(ctor->getParent())) {
-    llvm::report_fatal_error("defaulted move constructor without a fieldwise "
-                             "copy constructor is not supported");
-  }
-  if (ctor->isCopyOrMoveConstructor() &&
-      !IsUserDefinedCopyOrMoveConstructor(ctor)) {
+  if (ctor->isCopyConstructor() && !IsUserDefinedCopyConstructor(ctor)) {
     StrCat(PushSuppressIteratorClone::take(*this)
                ? ConvertRValue(expr->getArg(0))
                : ConvertFreshRValue(expr->getArg(0)));
@@ -1916,7 +1906,7 @@ bool ConverterRefCount::VisitCXXConstructExpr(clang::CXXConstructExpr *expr) {
     return false;
   }
 
-  assert(ctor->isUserProvided());
+  assert(ctor->isUserProvided() || IsUserDefinedMoveConstructor(ctor));
   if (expr->getType()->isArrayType()) {
     ConvertArrayCXXConstructExpr(expr);
   } else {
@@ -2513,20 +2503,18 @@ void ConverterRefCount::emplace_back_plugin_construct_arg(
   ConvertVarInit(elem_type, ctor);
 }
 
-void ConverterRefCount::emplace_back_emit_push_open(
-    clang::CXXMemberCallExpr *call) {
+void ConverterRefCount::emplace_back_emit_push(clang::CXXMemberCallExpr *call,
+                                               std::string_view arg) {
   auto *obj = GetCallObject(call);
   auto obj_type = obj->getType().getNonReferenceType();
   if (obj_type->isPointerType()) {
     obj_type = obj_type->getPointeeType();
   }
-  StrCat(ConvertObject(obj), ".with_mut(|__v: &mut ",
-         ToString(obj_type.getNonReferenceType()), "| __v.push(");
-}
-
-void ConverterRefCount::emplace_back_emit_push_close(
-    clang::CXXMemberCallExpr *call) {
-  StrCat("))");
+  StrCat(ConvertObject(obj), ".with_mut");
+  PushParen outer(*this);
+  StrCat("|__v: &mut ", ToString(obj_type.getNonReferenceType()), "| __v.push");
+  PushParen inner(*this);
+  StrCat(arg);
 }
 
 const char *
@@ -2667,7 +2655,7 @@ void ConverterRefCount::SetUFCSReceiver(clang::Expr *base, bool is_arrow,
     }
     return;
   }
-  if (!base->isLValue() && base->getType()->isRecordType() &&
+  if (IsTemporaryObject(base) && base->getType()->isRecordType() &&
       !IsReferenceType(base->IgnoreImplicit())) {
     PushConversionKind push(*this, ConversionKind::FullRefCount);
     ufcs_receiver_ =

cpp2rust/converter/models/converter_refcount.h

@@ -239,8 +239,8 @@ class ConverterRefCount final : public Converter {
   void
   emplace_back_plugin_construct_arg(clang::QualType elem_type,
                                     clang::CXXConstructExpr *ctor) override;
-  void emplace_back_emit_push_open(clang::CXXMemberCallExpr *call) override;
-  void emplace_back_emit_push_close(clang::CXXMemberCallExpr *call) override;
+  void emplace_back_emit_push(clang::CXXMemberCallExpr *call,
+                              std::string_view arg) override;
 
   const char *GetPointerDerefSuffix(clang::QualType pointee_type);
   const char *GetPointerDerefPrefix(clang::QualType pointee_type) override;