Merge branch 'master' into ironcev/marker-traits

Author: ironcev

sway-core/src/semantic_analysis/namespace/trait_map.rs

@@ -917,11 +917,6 @@ impl TraitMap {
                         *map_type_id,
                         *type_id,
                     );
-                    type_id.subst(&SubstTypesContext::new(
-                        engines,
-                        &type_mapping,
-                        matches!(code_block_first_pass, CodeBlockFirstPass::No),
-                    ));
                     let trait_items: TraitItems = map_trait_items
                         .clone()
                         .into_iter()

sway-core/src/type_system/unify/unify_check.rs

@@ -510,7 +510,8 @@ impl<'a> UnifyCheck<'a> {
                     // any type can be coerced into a generic,
                     // except if the type already contains the generic
                     (_e, _g @ UnknownGeneric { .. }) => {
-                        !OccursCheck::new(self.engines).check(right, left)
+                        matches!(self.mode, ConstraintSubset)
+                            || !OccursCheck::new(self.engines).check(right, left)
                     }
 
                     (Alias { ty: l_ty, .. }, Alias { ty: r_ty, .. }) => {

sway-lib-std/src/bytes.sw

@@ -816,6 +816,61 @@ impl Bytes {
 
         spliced
     }
+
+    /// Resizes the `Bytes` in-place so that `len` is equal to `new_len`.
+    ///
+    /// # Additional Information
+    ///
+    /// If `new_len` is greater than `len`, the `Bytes` is extended by the difference, with each additional slot filled with `value`. If `new_len` is less than `len`, the `Bytes` is simply truncated.
+    ///
+    /// # Arguments
+    ///
+    /// * `new_len`: [u64] - The new length of the `Bytes`.
+    /// * `value`: [u8] - The value to fill the new length.
+    ///
+    /// # Examples
+    ///
+    /// ```sway
+    /// fn foo() {
+    ///     let bytes = Bytes::new();
+    ///     bytes.resize(1, 7u8);
+    ///     assert(bytes.len() == 1);
+    ///     assert(bytes.get(0).unwrap() == 7u8);
+    ///
+    ///     bytes.resize(2, 9u8);
+    ///     assert(bytes.len() == 2);
+    ///     assert(bytes.get(0).unwrap() == 7u8);
+    ///     assert(bytes.get(1).unwrap() == 9u8);
+    ///
+    ///     bytes.resize(1, 0);
+    ///     assert(bytes.len() == 1);
+    ///     assert(bytes.get(0).unwrap() == 7u8);
+    ///     assert(bytes.get(1) == None);
+    /// }
+    /// ```
+    pub fn resize(ref mut self, new_len: u64, value: u8) {
+        // If the `new_len` is less then truncate
+        if self.len >= new_len {
+            self.len = new_len;
+            return;
+        }
+
+        // If we don't have enough capacity, alloc more
+        if self.buf.cap < new_len {
+            self.buf.ptr = realloc_bytes(self.buf.ptr, self.buf.cap, new_len);
+            self.buf.cap = new_len;
+        }
+
+        // Fill the new length with value
+        let mut i = 0;
+        let start_ptr = self.buf.ptr.add_uint_offset(self.len);
+        while i + self.len < new_len {
+            start_ptr.add_uint_offset(i).write_byte(value);
+            i += 1;
+        }
+
+        self.len = new_len;
+    }
 }
 
 impl core::ops::Eq for Bytes {
@@ -1020,57 +1075,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,
@@ -697,6 +698,61 @@ impl<T> Vec<T> {
     pub fn ptr(self) -> raw_ptr {
         self.buf.ptr()
     }
+
+    /// Resizes the `Vec` in-place so that `len` is equal to `new_len`.
+    ///
+    /// # Additional Information
+    ///
+    /// If `new_len` is greater than `len`, the `Vec` is extended by the difference, with each additional slot filled with `value`. If `new_len` is less than `len`, the `Vec` is simply truncated.
+    ///
+    /// # Arguments
+    ///
+    /// * `new_len`: [u64] - The new length of the `Vec`.
+    /// * `value`: [T] - The value to fill the new length.
+    ///
+    /// # Examples
+    ///
+    /// ```sway
+    /// fn foo() {
+    ///     let vec: Vec<u64> = Vec::new();
+    ///     vec.resize(1, 7);
+    ///     assert(vec.len() == 1);
+    ///     assert(vec.get(0).unwrap() == 7);
+    ///
+    ///     vec.resize(2, 9);
+    ///     assert(vec.len() == 2);
+    ///     assert(vec.get(0).unwrap() == 7);
+    ///     assert(vec.get(1).unwrap() == 9);
+    ///
+    ///     vec.resize(1, 0);
+    ///     assert(vec.len() == 1);
+    ///     assert(vec.get(0).unwrap() == 7);
+    ///     assert(vec.get(1) == None);
+    /// }
+    /// ```
+    pub fn resize(ref mut self, new_len: u64, value: T) {
+        // If the `new_len` is less then truncate
+        if self.len >= new_len {
+            self.len = new_len;
+            return;
+        }
+
+        // If we don't have enough capacity, alloc more
+        if self.buf.cap < new_len {
+            self.buf.ptr = realloc::<T>(self.buf.ptr, self.buf.cap, new_len);
+            self.buf.cap = new_len;
+        }
+
+        // Fill the new length with `value`
+        let mut i = 0;
+        let start_ptr = self.buf.ptr.add::<T>(self.len);
+        while i + self.len < new_len {
+            start_ptr.add::<T>(i).write::<T>(value);
+            i += 1;
+        }
+
+        self.len = new_len;
+    }
 }
 
 impl<T> AsRawSlice for Vec<T> {
@@ -791,26 +847,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/e2e_vm_tests/test_programs/should_pass/language/nested_generics/Forc.lock

@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-9C31758901D851EE"
+
+[[package]]
+name = "nested_generics"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "std"
+source = "path+from-root-9C31758901D851EE"
+dependencies = ["core"]