Add move rules for array, map, unique_ptr and vector

Author: lucic71

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())
+}

rules/unique_ptr/tgt_unsafe.rs

@@ -53,3 +53,19 @@ unsafe fn f10<T1: Default>() -> Option<Box<T1>> {
 unsafe fn f11<T1>() -> Option<Box<[T1]>> {
     None
 }
+
+unsafe fn f12<T1>(a0: &mut Option<Box<T1>>) -> Option<Box<T1>> {
+    a0.take()
+}
+
+unsafe fn f13<T1>(a0: &mut Option<Box<[T1]>>) -> Option<Box<[T1]>> {
+    a0.take()
+}
+
+unsafe fn f14<T1>(a0: &mut Option<Box<T1>>, a1: &mut Option<Box<T1>>) {
+    *a0 = a1.take()
+}
+
+unsafe fn f15<T1>(a0: &mut Option<Box<[T1]>>, a1: &mut Option<Box<[T1]>>) {
+    *a0 = a1.take()
+}

rules/vector/src.cpp

@@ -527,3 +527,12 @@ template <typename T1, typename T2 = std::allocator<T1>>
 void f106(std::vector<T1, T2> &o) {
   return o.shrink_to_fit();
 }
+
+template <typename T1> std::vector<T1> f107(std::vector<T1> &&o) {
+  return std::vector<T1>(std::move(o));
+}
+
+template <typename T1, typename T2 = std::allocator<T1>>
+std::vector<T1, T2> f108(std::vector<T1, T2> &&o) {
+  return std::vector<T1, T2>(std::move(o));
+}