Add more rules for move assignment and constructor (#362)

Author: lucic71

rules/array/src.cpp

@@ -29,3 +29,13 @@ 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));
 }
+
+template <typename T1, std::size_t T2>
+std::array<T1, T2> f6(const std::array<T1, T2> &o) {
+  return std::array<T1, T2>(o);
+}
+
+template <typename T1, std::size_t T2>
+std::array<T1, T2> &f7(std::array<T1, T2> &dst, const std::array<T1, T2> &src) {
+  return dst.operator=(src);
+}

rules/array/tgt_refcount.rs

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

rules/array/tgt_unsafe.rs

@@ -26,3 +26,11 @@ unsafe fn f4<T1>(a0: &mut Vec<T1>) -> Vec<T1> {
 unsafe fn f5<T1>(a0: &mut Vec<T1>, a1: &mut Vec<T1>) {
     *a0 = std::mem::take(&mut *a1)
 }
+
+unsafe fn f6<T1: Clone>(a0: Vec<T1>) -> Vec<T1> {
+    a0.clone()
+}
+
+unsafe fn f7<T1: Clone>(a0: &mut Vec<T1>, a1: Vec<T1>) {
+    *a0 = a1.clone()
+}

rules/builtin/src.cpp

@@ -1,6 +1,8 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
+#include <stddef.h>
+
 #if defined(__linux__)
 #include <byteswap.h>
 #elif !defined(__APPLE__)
@@ -26,3 +28,7 @@ bool f10(long long a, long long b, long long *r) { return __builtin_mul_overflow
 #if defined(__x86_64__) || defined(__i386__)
 void f11(void) { return __builtin_ia32_pause(); }
 #endif
+
+void *f14(void *dst, const void *src, size_t n) {
+  return __builtin_memcpy(dst, src, n);
+}

rules/builtin/tgt_refcount.rs

@@ -23,3 +23,8 @@ fn f13(a0: i64, a1: i64, a2: Ptr<i64>) -> bool {
     a2.write(val);
     ovf
 }
+
+fn f14(a0: AnyPtr, a1: AnyPtr, a2: usize) -> AnyPtr {
+    a0.memcpy(&a1, a2 as usize);
+    a0.clone()
+}

rules/builtin/tgt_unsafe.rs

@@ -50,3 +50,10 @@ unsafe fn f13(a0: i64, a1: i64, a2: *mut i64) -> bool {
     *a2 = val;
     ovf
 }
+
+unsafe fn f14(a0: *mut u8, a1: *const u8, a2: usize) -> *mut u8 {
+    if a2 != 0 {
+        ::std::ptr::copy_nonoverlapping(a1, a0, a2 as usize)
+    }
+    a0
+}

rules/deque/src.cpp

@@ -22,3 +22,21 @@ template <typename T1>
 void f7(std::deque<std::vector<T1>> &o, const std::vector<T1> &value) {
   return o.push_back(value);
 }
+
+template <typename T1> std::deque<T1> f8(const std::deque<T1> &o) {
+  return std::deque<T1>(o);
+}
+
+template <typename T1> std::deque<T1> f9(std::deque<T1> &&o) {
+  return std::deque<T1>(std::move(o));
+}
+
+template <typename T1>
+std::deque<T1> &f10(std::deque<T1> &dst, const std::deque<T1> &src) {
+  return dst.operator=(src);
+}
+
+template <typename T1>
+std::deque<T1> &f11(std::deque<T1> &dst, std::deque<T1> &&src) {
+  return dst.operator=(std::move(src));
+}

rules/deque/tgt_refcount.rs

@@ -16,3 +16,11 @@ fn f2<T1>(a0: Ptr<T1>) -> Ptr<T1> {
 fn f7<T1: ByteRepr>(a0: Ptr<Vec<Value<Vec<T1>>>>, a1: Value<Vec<T1>>) {
     a0.with_mut(|__v: &mut Vec<Value<Vec<T1>>>| __v.push(a1))
 }
+
+fn f10<T1: Clone + ByteRepr>(a0: Ptr<Vec<T1>>, a1: Vec<T1>) {
+    a0.write(a1.clone())
+}
+
+fn f11<T1: ByteRepr + Clone>(a0: Ptr<Vec<T1>>, a1: &mut Vec<T1>) {
+    a0.write(std::mem::take(&mut *a1))
+}

rules/deque/tgt_unsafe.rs

@@ -32,3 +32,19 @@ unsafe fn f5<T1>(a0: &mut Vec<T1>) -> T1 {
 unsafe fn f7<T1>(a0: &mut Vec<Vec<T1>>, a1: Vec<T1>) {
     a0.push(a1)
 }
+
+unsafe fn f8<T1: Clone>(a0: Vec<T1>) -> Vec<T1> {
+    a0.clone()
+}
+
+unsafe fn f9<T1>(a0: &mut Vec<T1>) -> Vec<T1> {
+    std::mem::take(&mut *a0)
+}
+
+unsafe fn f10<T1: Clone>(a0: &mut Vec<T1>, a1: Vec<T1>) {
+    *a0 = a1.clone()
+}
+
+unsafe fn f11<T1>(a0: &mut Vec<T1>, a1: &mut Vec<T1>) {
+    *a0 = std::mem::take(&mut *a1)
+}

rules/map/src.cpp

@@ -126,3 +126,8 @@ 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));
 }
+
+template <typename T1, typename T2>
+std::map<T1, T2> &f26(std::map<T1, T2> &dst, const std::map<T1, T2> &src) {
+  return dst.operator=(src);
+}