Merge branch 'master' into vec-decay

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -228,6 +228,11 @@ std::string Converter::ConvertPointerReceiver(clang::Expr *arg,
   return std::format("({} as {})", ConvertFreshObject(arg), param_type);
 }
 
+std::string Converter::ConvertTemporaryPointer(
+    clang::Expr *expr, std::optional<clang::QualType> implicit_convert_to) {
+  return std::format("&mut {}", ConvertFreshRValue(expr, implicit_convert_to));
+}
+
 std::string Converter::ConvertLValue(clang::Expr *expr) {
   PushExprKind push(*this, ExprKind::LValue);
   return ToString(expr);
@@ -3857,7 +3862,8 @@ bool Converter::VisitCXXConstructExpr(clang::CXXConstructExpr *expr) {
     return false;
   }
 
-  if (ctor->isDefaultConstructor() && !ctor->isUserProvided()) {
+  if (ctor->isDefaultConstructor() &&
+      !(ctor->isUserProvided() && IsUserDefinedDecl(ctor))) {
     auto ty = expr->getType();
     StrCat(GetDefaultAsString(ty));
     SetFreshType(expr->getType());
@@ -5159,17 +5165,23 @@ std::string Converter::ConvertPlaceholder(clang::Expr *expr, clang::Expr *arg,
   }
 
   if (ph_ctx.needs_ptr_wrap()) {
+    if (clang::isa<clang::MaterializeTemporaryExpr>(arg)) {
+      return ConvertTemporaryPointer(arg, ph_ctx.implicit_convert_to);
+    }
     return ConvertFreshObject(arg);
   }
 
   if (ph_ctx.needs_lvalue()) {
     return ConvertBorrowMut(arg);
   }
 
-  if (ph_ctx.access == TranslationRule::Access::kTake) {
-    if (clang::isa<clang::MaterializeTemporaryExpr>(arg)) {
-      return ConvertRValue(arg);
-    }
+  // The rule takes the argument by value from an rvalue reference parameter,
+  // e.g., push_back(T &&), and so C++ moves it.
+  auto param_type = GetParamType(expr, ph_ctx.arg_idx);
+  bool moved = ph_ctx.access == TranslationRule::Access::kTake ||
+               (ph_ctx.access == TranslationRule::Access::kMove && param_type &&
+                (*param_type)->isRValueReferenceType());
+  if (moved && !clang::isa<clang::MaterializeTemporaryExpr>(arg)) {
     if (auto *record = arg->getType()->getAsCXXRecordDecl();
         record && IsUserDefinedDecl(record)) {
       for (auto *ctor : record->ctors()) {
@@ -5185,6 +5197,12 @@ std::string Converter::ConvertPlaceholder(clang::Expr *expr, clang::Expr *arg,
       }
       return ConvertFreshRValue(arg);
     }
+  }
+
+  if (ph_ctx.access == TranslationRule::Access::kTake) {
+    if (clang::isa<clang::MaterializeTemporaryExpr>(arg)) {
+      return ConvertRValue(arg);
+    }
     return ConvertTake(arg);
   }
 

cpp2rust/converter/converter.h

@@ -1080,6 +1080,13 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual std::string ConvertPointerReceiver(clang::Expr *arg,
                                              std::string_view param_type);
+
+  // A pointer to a new temporary with the value of the prvalue expr, which
+  // lives until the end of the statement.
+  virtual std::string
+  ConvertTemporaryPointer(clang::Expr *expr,
+                          std::optional<clang::QualType> implicit_convert_to);
+
   std::string
   ConvertPointer(clang::Expr *expr,
                  std::optional<clang::QualType> implicit_convert_to = {},

cpp2rust/converter/converter_lib.cpp

@@ -1984,8 +1984,8 @@ bool HasReceiver(clang::Expr *expr) {
   return false;
 }
 
-std::optional<clang::QualType> GetParamImplicitConvertTarget(clang::Expr *expr,
-                                                             unsigned arg_idx) {
+std::optional<clang::QualType> GetParamType(clang::Expr *expr,
+                                            unsigned arg_idx) {
   const clang::FunctionDecl *fn = nullptr;
   if (auto *call = clang::dyn_cast<clang::CallExpr>(expr)) {
     fn = call->getDirectCallee();
@@ -1999,7 +1999,16 @@ std::optional<clang::QualType> GetParamImplicitConvertTarget(clang::Expr *expr,
   if (param_idx >= fn->getNumParams()) {
     return std::nullopt;
   }
-  return fn->getParamDecl(param_idx)->getType().getNonReferenceType();
+  return fn->getParamDecl(param_idx)->getType();
+}
+
+std::optional<clang::QualType> GetParamImplicitConvertTarget(clang::Expr *expr,
+                                                             unsigned arg_idx) {
+  auto type = GetParamType(expr, arg_idx);
+  if (!type) {
+    return std::nullopt;
+  }
+  return type->getNonReferenceType();
 }
 
 bool IsAliasOfInit(clang::ASTContext &ctx, const clang::VarDecl *var) {

cpp2rust/converter/converter_lib.h

@@ -318,6 +318,9 @@ bool ArgsMayAlias(const clang::Expr *a, const clang::Expr *b);
 
 bool HasReceiver(clang::Expr *expr);
 
+std::optional<clang::QualType> GetParamType(clang::Expr *expr,
+                                            unsigned arg_idx);
+
 std::optional<clang::QualType> GetParamImplicitConvertTarget(clang::Expr *expr,
                                                              unsigned arg_idx);
 

cpp2rust/converter/models/converter_refcount.cpp

@@ -413,6 +413,12 @@ std::string ConverterRefCount::ConvertFreshObject(clang::Expr *expr) {
   return std::format("({}).clone()", std::move(str));
 }
 
+std::string ConverterRefCount::ConvertTemporaryPointer(
+    clang::Expr *expr, std::optional<clang::QualType> implicit_convert_to) {
+  return std::format("Rc::new(RefCell::new({})).as_pointer()",
+                     ConvertFreshRValue(expr, implicit_convert_to));
+}
+
 std::string ConverterRefCount::ConvertFresh(
     clang::Expr *expr, std::optional<clang::QualType> implicit_convert_to) {
   auto str = ToString(expr, implicit_convert_to);
@@ -2325,7 +2331,8 @@ bool ConverterRefCount::VisitCXXConstructExpr(clang::CXXConstructExpr *expr) {
     return false;
   }
 
-  if (ctor->isDefaultConstructor() && !ctor->isUserProvided()) {
+  if (ctor->isDefaultConstructor() &&
+      !(ctor->isUserProvided() && IsUserDefinedDecl(ctor))) {
     auto ty = expr->getType();
     StrCat(GetDefaultAsString(ty));
     SetFreshType(ty);

cpp2rust/converter/models/converter_refcount.h

@@ -399,6 +399,11 @@ class ConverterRefCount final : public Converter {
                                      std::string_view param_type) override;
 
   std::string AsPointerMethod(clang::QualType type) const;
+
+  std::string ConvertTemporaryPointer(
+      clang::Expr *expr,
+      std::optional<clang::QualType> implicit_convert_to) override;
+
   bool WantsElementPtr() const { return object_shape_ == ObjectShape::Element; }
   std::string
   ConvertFresh(clang::Expr *expr,

libcc2rs/src/swap.rs

@@ -85,6 +85,27 @@ macro_rules! cpp_swap_unsafe {
     }};
 }
 
+// cpp_move!(p), or cpp_move_unsafe!(p), constructs a value from the one that
+// p points to as C++ does with T(std::move(*p)), like the temporary of the
+// swap.
+#[macro_export]
+macro_rules! cpp_move {
+    ($p:expr) => {{
+        #[allow(unused_imports)]
+        use $crate::__swap::{ConstructCopy, ConstructMove, ConstructNone};
+        (&&&$crate::__swap::Construct(&$p)).construct()
+    }};
+}
+
+#[macro_export]
+macro_rules! cpp_move_unsafe {
+    ($p:expr) => {{
+        #[allow(unused_imports)]
+        use $crate::__swap::{ConstructCopyUnsafe, ConstructMoveUnsafe, ConstructNoneUnsafe};
+        unsafe { (&&&$crate::__swap::ConstructUnsafe($p)).construct() }
+    }};
+}
+
 // Whether the type has none of the special members that the swap calls.
 macro_rules! trivial {
     ($wrapper:ident, $ptr:ty, $none:ident, $($tr:ident: $bound:ident for $recv:ty),*) => {