Add move rules for STL containers (#360)

Don't special case the move constructor of unique_ptr inside the
converter. Instead add a rule for it.

Also added move constructs and assignment rules for array, vector, map.

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -1765,12 +1765,7 @@ bool Converter::VisitCallExpr(clang::CallExpr *expr) {
   }
 
   if (expr->isCallToStdMove()) {
-    if (IsUniquePtr(expr->getArg(0)->getType())) {
-      StrCat(std::format("{}.take()", ConvertLValue(expr->getArg(0))));
-      computed_expr_type_ = ComputedExprType::FreshValue;
-      return false;
-    }
-    StrCat(std::format("{}", ToString(expr->getArg(0))));
+    Convert(expr->getArg(0));
     return false;
   }
 

cpp2rust/converter/models/converter_refcount.cpp

@@ -1151,15 +1151,9 @@ bool ConverterRefCount::VisitStringLiteral(clang::StringLiteral *expr) {
 bool ConverterRefCount::VisitImplicitCastExpr(clang::ImplicitCastExpr *expr) {
   auto *sub_expr = expr->getSubExpr();
 
-  // return unique_ptr (implicit xvalue cast)
   if (expr->isXValue() && sub_expr->isLValue()) {
     Convert(sub_expr);
-    if (IsUniquePtr(sub_expr->getType())) {
-      StrCat(".take()");
-      computed_expr_type_ = ComputedExprType::FreshValue;
-    } else {
-      computed_expr_type_ = ComputedExprType::Value;
-    }
+    computed_expr_type_ = ComputedExprType::Value;
     return false;
   }
 
@@ -2578,6 +2572,10 @@ std::string ConverterRefCount::ConvertMappedMethodCall(
 
   auto arg_idx = receiver_ph->n;
   auto *arg = BuildUnifiedArgs(expr, args, num_args)[arg_idx];
+  if (auto *call = clang::dyn_cast<clang::CallExpr>(arg->IgnoreCasts());
+      call && call->isCallToStdMove()) {
+    arg = call->getArg(0);
+  }
 
   if (!arg->getType()->isPointerType() && !IsReferenceType(arg)) {
     return Converter::ConvertMappedMethodCall(expr, mc, args, num_args, ctx);

rules/array/src.cpp

@@ -19,3 +19,13 @@ std::size_t f2(const std::array<T1, T2> &o) {
 template <typename T1, std::size_t T2> T1 *f3(std::array<T1, T2> &o) {
   return o.data();
 }
+
+template <typename T1, std::size_t T2>
+std::array<T1, T2> f4(std::array<T1, T2> &&o) {
+  return std::array<T1, T2>(std::move(o));
+}
+
+template <typename T1, std::size_t T2>
+std::array<T1, T2> &f5(std::array<T1, T2> &dst, std::array<T1, T2> &&src) {
+  return dst.operator=(std::move(src));
+}

rules/array/tgt_refcount.rs

@@ -12,3 +12,7 @@ fn f1<T1>(a0: Ptr<T1>) -> Ptr<T1> {
 fn f3<T1>(a0: Ptr<T1>) -> Ptr<T1> {
     a0
 }
+
+fn f5<T1: ByteRepr + Clone>(a0: Ptr<Vec<T1>>, a1: &mut Vec<T1>) {
+    a0.write(std::mem::take(&mut *a1))
+}

rules/array/tgt_unsafe.rs

@@ -18,3 +18,11 @@ unsafe fn f2<T1>(a0: Vec<T1>) -> usize {
 unsafe fn f3<T1>(a0: &mut Vec<T1>) -> *mut T1 {
     a0.as_mut_ptr()
 }
+
+unsafe fn f4<T1>(a0: &mut Vec<T1>) -> Vec<T1> {
+    std::mem::take(&mut *a0)
+}
+
+unsafe fn f5<T1>(a0: &mut Vec<T1>, a1: &mut Vec<T1>) {
+    *a0 = std::mem::take(&mut *a1)
+}

rules/map/src.cpp

@@ -117,3 +117,12 @@ template <typename T1, typename T2>
 T2 &f23(typename std::map<T1, T2>::iterator it) {
   return it->second;
 }
+
+template <typename T1, typename T2> std::map<T1, T2> f24(std::map<T1, T2> &&o) {
+  return std::map<T1, T2>(std::move(o));
+}
+
+template <typename T1, typename T2>
+std::map<T1, T2> &f25(std::map<T1, T2> &dst, std::map<T1, T2> &&src) {
+  return dst.operator=(std::move(src));
+}

rules/map/tgt_refcount.rs

@@ -139,3 +139,15 @@ fn f22<T1: Ord + Clone + 'static, T2: 'static>(a0: RefcountMapIter<T1, T2>) -> V
 fn f23<T1: Ord + Clone + 'static, T2: 'static>(a0: RefcountMapIter<T1, T2>) -> Value<T2> {
     a0.second()
 }
+
+fn f24<T1: 'static, T2: 'static>(a0: Ptr<BTreeMap<T1, Value<T2>>>) -> BTreeMap<T1, Value<T2>> {
+    a0.with_mut(|__v: &mut BTreeMap<T1, Value<T2>>| std::mem::take(__v))
+}
+
+fn f25<T1: 'static, T2: 'static>(
+    a0: Ptr<BTreeMap<T1, Value<T2>>>,
+    a1: Ptr<BTreeMap<T1, Value<T2>>>,
+) {
+    let __src = a1.with_mut(|__v: &mut BTreeMap<T1, Value<T2>>| std::mem::take(__v));
+    a0.write(__src)
+}

rules/map/tgt_unsafe.rs

@@ -102,3 +102,11 @@ unsafe fn f22<T1: Ord + Clone, T2>(a0: UnsafeMapIterator<T1, T2>) -> *const T1 {
 unsafe fn f23<T1: Ord + Clone, T2>(a0: UnsafeMapIterator<T1, T2>) -> *mut T2 {
     a0.second()
 }
+
+unsafe fn f24<T1, T2>(a0: &mut BTreeMap<T1, Box<T2>>) -> BTreeMap<T1, Box<T2>> {
+    std::mem::take(&mut *a0)
+}
+
+unsafe fn f25<T1, T2>(a0: &mut BTreeMap<T1, Box<T2>>, a1: &mut BTreeMap<T1, Box<T2>>) {
+    *a0 = std::mem::take(&mut *a1)
+}

rules/unique_ptr/src.cpp

@@ -55,3 +55,22 @@ template <typename T1> std::unique_ptr<T1> f10() {
 template <typename T1> std::unique_ptr<T1[]> f11() {
   return std::unique_ptr<T1[]>();
 }
+
+template <typename T1> std::unique_ptr<T1> f12(std::unique_ptr<T1> &&o) {
+  return std::unique_ptr<T1>(std::move(o));
+}
+
+template <typename T1> std::unique_ptr<T1[]> f13(std::unique_ptr<T1[]> &&o) {
+  return std::unique_ptr<T1[]>(std::move(o));
+}
+
+template <typename T1>
+std::unique_ptr<T1> &f14(std::unique_ptr<T1> &dst, std::unique_ptr<T1> &&src) {
+  return dst.operator=(std::move(src));
+}
+
+template <typename T1>
+std::unique_ptr<T1[]> &f15(std::unique_ptr<T1[]> &dst,
+                           std::unique_ptr<T1[]> &&src) {
+  return dst.operator=(std::move(src));
+}

rules/unique_ptr/tgt_refcount.rs

@@ -59,3 +59,19 @@ fn f10<T1>() -> Option<Value<T1>> {
 fn f11<T1>() -> Option<Value<Box<[T1]>>> {
     None
 }
+
+fn f12<T1>(a0: &mut Option<Value<T1>>) -> Option<Value<T1>> {
+    a0.take()
+}
+
+fn f13<T1>(a0: &mut Option<Value<Box<[T1]>>>) -> Option<Value<Box<[T1]>>> {
+    a0.take()
+}
+
+fn f14<T1: ByteRepr>(a0: Ptr<Option<Value<T1>>>, a1: &mut Option<Value<T1>>) {
+    a0.write(a1.take())
+}
+
+fn f15<T1: ByteRepr>(a0: Ptr<Option<Value<Box<[T1]>>>>, a1: &mut Option<Value<Box<[T1]>>>) {
+    a0.write(a1.take())
+}