Add Clone implementation for String and Vec (#6865)

## Description

This PR implements the `Clone` for `String` and `Vec`.

## Checklist

- [x] I have linked to any relevant issues.
- [x] I have commented my code, particularly in hard-to-understand
areas.
- [x] I have updated the documentation where relevant (API docs, the
reference, and the Sway book).
- [x] If my change requires substantial documentation changes, I have
[requested support from the DevRel
team](https://github.com/FuelLabs/devrel-requests/issues/new/choose)
- [x] I have added tests that prove my fix is effective or that my
feature works.
- [x] I have added (or requested a maintainer to add) the necessary
`Breaking*` or `New Feature` labels where relevant.
- [x] I have done my best to ensure that my PR adheres to [the Fuel Labs
Code Review
Standards](https://github.com/FuelLabs/rfcs/blob/master/text/code-standards/external-contributors.md).
- [x] I have requested a review from the relevant team or maintainers.

Author: bitzoic

sway-lib-std/src/bytes.sw

@@ -1020,57 +1020,3 @@ impl AbiDecode for Bytes {
         raw_slice::abi_decode(buffer).into()
     }
 }
-
-#[test]
-fn ok_bytes_buffer_ownership() {
-    let mut original_array = [1u8, 2u8, 3u8, 4u8];
-    let slice = raw_slice::from_parts::<u8>(__addr_of(original_array), 4);
-
-    // Check Bytes duplicates the original slice
-    let mut bytes = Bytes::from(slice);
-    bytes.set(0, 5);
-    assert(original_array[0] == 1);
-
-    // At this point, slice equals [5, 2, 3, 4]
-    let encoded_slice = encode(bytes);
-
-    // `Bytes` should duplicate the underlying buffer,
-    // so when we write to it, it should not change
-    // `encoded_slice` 
-    let mut bytes = abi_decode::<Bytes>(encoded_slice);
-    bytes.set(0, 6);
-    assert(bytes.get(0) == Some(6));
-
-    let mut bytes = abi_decode::<Bytes>(encoded_slice);
-    assert(bytes.get(0) == Some(5));
-}
-
-#[test]
-fn ok_bytes_bigger_than_3064() {
-    let mut v: Bytes = Bytes::new();
-
-    // We allocate 1024 bytes initially, this is throw away because 
-    // it is not big enough for the buffer.
-    // Then we used to double the buffer to 2048.
-    // Then we write an `u64` with the length of the buffer.
-    // Then we write the buffer itself.
-    // (1024 + 2048) - 8 = 3064
-    // Thus, we need a buffer with 3065 bytes to write into the red zone
-    let mut a = 3065;
-    while a > 0 {
-        v.push(1u8);
-        a -= 1;
-    }
-
-    // This red zone should not be overwritten
-    let red_zone = asm(size: 1024) {
-        aloc size;
-        hp: raw_ptr
-    };
-    red_zone.write(0xFFFFFFFFFFFFFFFF);
-    assert(red_zone.read::<u64>() == 0xFFFFFFFFFFFFFFFF);
-
-    let _ = encode(v);
-
-    assert(red_zone.read::<u64>() == 0xFFFFFFFFFFFFFFFF);
-}

sway-lib-std/src/prelude.sw

@@ -25,6 +25,7 @@ pub use ::revert::{require, revert, revert_with_log};
 
 // Convert
 pub use ::convert::From;
+pub use ::clone::Clone;
 
 // Primitive conversions
 pub use ::primitive_conversions::{b256::*, str::*, u16::*, u256::*, u32::*, u64::*, u8::*};

sway-lib-std/src/string.sw

@@ -6,6 +6,7 @@ use ::bytes::*;
 use ::convert::*;
 use ::hash::{Hash, Hasher};
 use ::option::Option;
+use ::clone::Clone;
 
 /// A UTF-8 encoded growable string. It has ownership over its buffer.
 ///
@@ -341,3 +342,11 @@ impl AbiDecode for String {
         }
     }
 }
+
+impl Clone for String {
+    fn clone(self) -> Self {
+        Self {
+            bytes: self.bytes.clone(),
+        }
+    }
+}

sway-lib-std/src/vec.sw

@@ -6,6 +6,7 @@ use ::assert::assert;
 use ::option::Option::{self, *};
 use ::convert::From;
 use ::iterator::*;
+use ::clone::Clone;
 
 struct RawVec<T> {
     ptr: raw_ptr,
@@ -791,26 +792,13 @@ impl<T> Iterator for VecIter<T> {
     }
 }
 
-#[test]
-fn ok_vec_buffer_ownership() {
-    let mut original_array = [1u8, 2u8, 3u8, 4u8];
-    let slice = raw_slice::from_parts::<u8>(__addr_of(original_array), 4);
-
-    // Check Vec duplicates the original slice
-    let mut bytes = Vec::<u8>::from(slice);
-    bytes.set(0, 5);
-    assert(original_array[0] == 1);
-
-    // At this point, slice equals [5, 2, 3, 4]
-    let encoded_slice = encode(bytes);
-
-    // `Vec<u8>` should duplicate the underlying buffer,
-    // so when we write to it, it should not change
-    // `encoded_slice` 
-    let mut bytes = abi_decode::<Vec<u8>>(encoded_slice);
-    bytes.set(0, 6);
-    assert(bytes.get(0) == Some(6));
-
-    let mut bytes = abi_decode::<Vec<u8>>(encoded_slice);
-    assert(bytes.get(0) == Some(5));
+impl<T> Clone for Vec<T> {
+    fn clone(self) -> Self {
+        let len = self.len();
+        let buf = RawVec::with_capacity(len);
+        if len > 0 {
+            self.ptr().copy_to::<T>(buf.ptr(), len);
+        }
+        Self { buf, len }
+    }
 }

test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-vec/reduced_lib.config

@@ -8,3 +8,4 @@ revert.sw
 vec.sw
 iterator.sw
 convert.sw
+clone.sw

test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-vec/src/lib.sw

@@ -9,6 +9,7 @@ pub mod assert;
 pub mod convert;
 pub mod alloc;
 pub mod iterator;
+pub mod clone;
 pub mod vec;
 
 pub mod prelude;

test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-vec/src/prelude.sw

@@ -14,6 +14,7 @@ pub use ::revert::{require, revert};
 
 // Convert
 pub use ::convert::From;
+pub use ::clone::Clone;
 
 // Logging
 pub use ::logging::log;

test/src/in_language_tests/test_programs/bytes_inline_tests/src/main.sw

@@ -1024,12 +1024,66 @@ fn bytes_clone() {
     assert(cloned_bytes.ptr() != bytes.ptr());
     assert(cloned_bytes.len() == bytes.len());
     // Capacity is not cloned
-    // assert(cloned_bytes.capacity() == bytes.capacity());
+    assert(cloned_bytes.capacity() != bytes.capacity());
     assert(cloned_bytes.get(0).unwrap() == bytes.get(0).unwrap());
     assert(cloned_bytes.get(1).unwrap() == bytes.get(1).unwrap());
     assert(cloned_bytes.get(2).unwrap() == bytes.get(2).unwrap());
 }
 
+#[test]
+fn bytes_buffer_ownership() {
+    let mut original_array = [1u8, 2u8, 3u8, 4u8];
+    let slice = raw_slice::from_parts::<u8>(__addr_of(original_array), 4);
+
+    // Check Bytes duplicates the original slice
+    let mut bytes = Bytes::from(slice);
+    bytes.set(0, 5);
+    assert(original_array[0] == 1);
+
+    // At this point, slice equals [5, 2, 3, 4]
+    let encoded_slice = encode(bytes);
+
+    // `Bytes` should duplicate the underlying buffer,
+    // so when we write to it, it should not change
+    // `encoded_slice` 
+    let mut bytes = abi_decode::<Bytes>(encoded_slice);
+    bytes.set(0, 6);
+    assert(bytes.get(0) == Some(6));
+
+    let mut bytes = abi_decode::<Bytes>(encoded_slice);
+    assert(bytes.get(0) == Some(5));
+}
+
+#[test]
+fn bytes_bigger_than_3064() {
+    let mut v: Bytes = Bytes::new();
+
+    // We allocate 1024 bytes initially, this is throw away because 
+    // it is not big enough for the buffer.
+    // Then we used to double the buffer to 2048.
+    // Then we write an `u64` with the length of the buffer.
+    // Then we write the buffer itself.
+    // (1024 + 2048) - 8 = 3064
+    // Thus, we need a buffer with 3065 bytes to write into the red zone
+    let mut a = 3065;
+    while a > 0 {
+        v.push(1u8);
+        a -= 1;
+    }
+
+    // This red zone should not be overwritten
+    let red_zone = asm(size: 1024) {
+        aloc size;
+        hp: raw_ptr
+    };
+    red_zone.write(0xFFFFFFFFFFFFFFFF);
+    assert(red_zone.read::<u64>() == 0xFFFFFFFFFFFFFFFF);
+
+    let _ = encode(v);
+
+    assert(red_zone.read::<u64>() == 0xFFFFFFFFFFFFFFFF);
+}
+
 #[test]
 pub fn test_encode_decode() {
     let initial = 0x3333333333333333333333333333333333333333333333333333333333333333;

test/src/in_language_tests/test_programs/string_inline_tests/src/main.sw

@@ -380,3 +380,16 @@ fn string_test_abi_encoding() {
 
     assert(string == decoded_string);
 }
+
+#[test]
+fn string_clone() {
+    let string = String::from_ascii_str("fuel");
+
+    let cloned_string = string.clone();
+
+    assert(cloned_string.ptr() != string.ptr());
+    assert(cloned_string.as_bytes().len() == string.as_bytes().len());
+    assert(cloned_string.as_bytes().get(0).unwrap() == string.as_bytes().get(0).unwrap());
+    assert(cloned_string.as_bytes().get(1).unwrap() == string.as_bytes().get(1).unwrap());
+    assert(cloned_string.as_bytes().get(2).unwrap() == string.as_bytes().get(2).unwrap());
+}

test/src/in_language_tests/test_programs/vec_inline_tests/src/main.sw

@@ -687,6 +687,45 @@ fn vec_raw_slice_into() {
     assert(vec.len() == slice.len::<u64>());
 }
 
+#[test]
+fn vec_clone() {
+    let (mut vec, _a, _b, _c) = setup();
+
+    let cloned_vec = vec.clone();
+
+    assert(cloned_vec.ptr() != vec.ptr());
+    assert(cloned_vec.len() == vec.len());
+    // Capacity is not cloned
+    assert(cloned_vec.capacity() != vec.capacity());
+    assert(cloned_vec.get(0).unwrap() == vec.get(0).unwrap());
+    assert(cloned_vec.get(1).unwrap() == vec.get(1).unwrap());
+    assert(cloned_vec.get(2).unwrap() == vec.get(2).unwrap());
+}
+
+#[test]
+fn vec_buffer_ownership() {
+    let mut original_array = [1u8, 2u8, 3u8, 4u8];
+    let slice = raw_slice::from_parts::<u8>(__addr_of(original_array), 4);
+
+    // Check Vec duplicates the original slice
+    let mut bytes = Vec::<u8>::from(slice);
+    bytes.set(0, 5);
+    assert(original_array[0] == 1);
+
+    // At this point, slice equals [5, 2, 3, 4]
+    let encoded_slice = encode(bytes);
+
+    // `Vec<u8>` should duplicate the underlying buffer,
+    // so when we write to it, it should not change
+    // `encoded_slice` 
+    let mut bytes = abi_decode::<Vec<u8>>(encoded_slice);
+    bytes.set(0, 6);
+    assert(bytes.get(0) == Some(6));
+
+    let mut bytes = abi_decode::<Vec<u8>>(encoded_slice);
+    assert(bytes.get(0) == Some(5));
+}
+
 #[test()]
 fn vec_encode_and_decode() {
     let mut v1: Vec<u64> = Vec::new();