(index_offset),\\n+ content_after_removed_len,\\n+ );\\n+ }\\n+\\n+ // 4. Write new content without the removed element to storage.\\n+ __state_store_slot(self.field_id(), content_ptr, new_len_in_bytes);\\n+\\n+ removed_element\\n+ }\\n+ }\\n+\\n+ /// Replaces the element at the given `index` with the last element, and removes the last element.\\n+ /// Returns the replaced element.\\n+ ///\\n+ /// # Additional Information\\n+ ///\\n+ /// **This method is not supported for nested storage types and will panic if `V` is a nested storage type.**\\n+ ///\\n+ /// If `index` is the index of the last element, the last element will be returned and removed from the vector.\\n+ ///\\n+ /// # Arguments\\n+ ///\\n+ /// * `index`: [u64] - The index at which to replace the element with the last element.\\n+ ///\\n+ /// # Returns\\n+ ///\\n+ /// * [V] - The replaced element.\\n+ ///\\n+ /// # Panics\\n+ ///\\n+ /// * `StorageVecError::IndexOutOfBounds`, if `index` is out of bounds.\\n+ /// * `StorageVecError::MethodDoesNotSupportNestedStorageTypes`, if `V` is a nested storage type, i.e. if it is a zero-sized type.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// * Preloads: `1` (to get vector's length)\\n+ /// * Loads: `1` (to read current slot content)\\n+ /// * Writes: `1` (to write content with the last element placed at `index`, truncated by one element)\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// use std::storage::storage_vec::*;\\n+ ///\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {}\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// storage.vec.push(5);\\n+ /// storage.vec.push(10);\\n+ /// storage.vec.push(15);\\n+ /// let removed_value = storage.vec.swap_remove(0);\\n+ /// assert_eq(5, removed_value);\\n+ /// let swapped_value = storage.vec.get(0).unwrap().read();\\n+ /// assert_eq(15, swapped_value); // The first element is replaced by the last element.\\n+ /// assert_eq(2, storage.vec.len()); // The last element is removed.\\n+ /// }\\n+ /// ```\\n+ #[storage(write)]\\n+ pub fn swap_remove(self, index: u64) -> V {\\n+ const STORES_STORAGE_TYPE: bool = __size_of::<V>() == 0;\\n+\\n+ if STORES_STORAGE_TYPE {\\n+ // This workaround for satisfying the `#[storage]` attribute\\n+ // is explained in the comment above this `StorageVec` impl.\\n+ let _ = __state_clear(b256::zero(), 0);\\n+ panic StorageVecError::MethodDoesNotSupportNestedStorageTypes;\\n+ } else {\\n+ const SIZE_OF_V: u64 = __size_of::<V>();\\n+\\n+ let len = __state_preload(self.field_id()) / SIZE_OF_V;\\n+\\n+ if index >= len {\\n+ panic StorageVecError::IndexOutOfBounds(OutOfBounds {\\n+ length: len,\\n+ index,\\n+ });\\n+ }\\n+\\n+ let len_in_bytes = len * SIZE_OF_V;\\n+ let index_offset = index * SIZE_OF_V;\\n+ let new_len_in_bytes = len_in_bytes - SIZE_OF_V;\\n+\\n+ // 1. Read current slot content.\\n+ let content_ptr = alloc_bytes(len_in_bytes);\\n+ let _ = __state_load_slot(self.field_id(), content_ptr, 0, len_in_bytes);\\n+\\n+ // 2. Read the element to be replaced/removed before overriding the content.\\n+ let removed_element = content_ptr.add::<u8>(index_offset).read::<V>();\\n+\\n+ // 3. Overwrite element at `index` with the last element (only if `index` is not already the last).\\n+ if index != len - 1 {\\n+ let last_element_ptr = content_ptr.add::<u8>(new_len_in_bytes);\\n+ last_element_ptr.copy_bytes_to(content_ptr.add::<u8>(index_offset), SIZE_OF_V);\\n+ }\\n+\\n+ // 4. Write new content without the last element to storage.\\n+ __state_store_slot(self.field_id(), content_ptr, new_len_in_bytes);\\n+\\n+ removed_element\\n+ }\\n+ }\\n+\\n+ /// Sets the `value` at the given `index`.\\n+ ///\\n+ /// # Additional Information\\n+ ///\\n+ /// **This method is not supported for nested storage types and will panic if `V` is a nested storage type.**\\n+ ///\\n+ /// # Arguments\\n+ ///\\n+ /// * `index`: [u64] - The index to set the value at.\\n+ /// * `value`: [V] - The value to be set.\\n+ ///\\n+ /// # Panics\\n+ ///\\n+ /// * `StorageVecError::IndexOutOfBounds`, if `index` is out of bounds.\\n+ /// * `StorageVecError::MethodDoesNotSupportNestedStorageTypes`, if `V` is a nested storage type, i.e. if it is a zero-sized type.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// * Preloads: `1` (to get the vector's length)\\n+ /// * Writes: `1`\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// use std::storage::storage_vec::*;\\n+ ///\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {}\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// storage.vec.push(5);\\n+ /// storage.vec.push(10);\\n+ ///\\n+ /// storage.vec.set(0, 15);\\n+ /// let set_value = storage.vec.get(0).unwrap().read();\\n+ /// assert_eq(15, set_value);\\n+ /// }\\n+ /// ```\\n+ #[storage(write)]\\n+ pub fn set(self, index: u64, value: V) {\\n+ const STORES_STORAGE_TYPE: bool = __size_of::<V>() == 0;\\n+\\n+ if STORES_STORAGE_TYPE {\\n+ // This workaround for satisfying the `#[storage]` attribute\\n+ // is explained in the comment above this `StorageVec` impl.\\n+ let _ = __state_clear(b256::zero(), 0);\\n+ panic StorageVecError::MethodDoesNotSupportNestedStorageTypes;\\n+ } else {\\n+ const SIZE_OF_V: u64 = __size_of::<V>();\\n+\\n+ let len = __state_preload(self.field_id()) / SIZE_OF_V;\\n+ if index >= len {\\n+ panic StorageVecError::IndexOutOfBounds(OutOfBounds {\\n+ length: len,\\n+ index,\\n+ });\\n+ }\\n+\\n+ __state_update_slot(\\n+ self\\n+ .field_id(),\\n+ __addr_of::<V>(value),\\n+ index * SIZE_OF_V,\\n+ SIZE_OF_V,\\n+ );\\n+ }\\n+ }\\n+\\n+ /// Inserts the `value` at the given `index`, moving the current value at `index`\\n+ /// as well as the following indices up by one index.\\n+ ///\\n+ /// # Additional Information\\n+ ///\\n+ /// **This method is not supported for nested storage types and will panic if `V` is a nested storage type.**\\n+ ///\\n+ /// If `index` is equal to vector's length, appends the `value` at the end of the\\n+ /// vector, effectively acting the same as `push`.\\n+ ///\\n+ /// # Arguments\\n+ ///\\n+ /// * `index`: [u64] - The index to insert the value into.\\n+ /// * `value`: [V] - The value to insert.\\n+ ///\\n+ /// # Panics\\n+ ///\\n+ /// * `StorageVecError::IndexOutOfBounds`, if `index` is larger than the length of the vector.\\n+ /// * `StorageVecError::MethodDoesNotSupportNestedStorageTypes`, if `V` is a nested storage type, i.e. if it is a zero-sized type.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// * Preloads: `1` (to get vector's length)\\n+ /// * Loads: `0` in case of an append at the end, or `1` if inserting\\n+ /// * Writes: `1` in case of an append at the end, or `2` if inserting\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// use std::storage::storage_vec::*;\\n+ ///\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {}\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// storage.vec.push(5);\\n+ /// storage.vec.push(15);\\n+ ///\\n+ /// storage.vec.insert(1, 10);\\n+ ///\\n+ /// assert_eq(5, storage.vec.get(0).unwrap().read());\\n+ /// assert_eq(10, storage.vec.get(1).unwrap().read());\\n+ /// assert_eq(15, storage.vec.get(2).unwrap().read());\\n+ /// }\\n+ /// ```\\n+ #[storage(write)]\\n+ pub fn insert(self, index: u64, value: V) {\\n+ const STORES_STORAGE_TYPE: bool = __size_of::<V>() == 0;\\n+\\n+ if STORES_STORAGE_TYPE {\\n+ // This workaround for satisfying the `#[storage]` attribute\\n+ // is explained in the comment above this `StorageVec` impl.\\n+ let _ = __state_clear(b256::zero(), 0);\\n+ panic StorageVecError::MethodDoesNotSupportNestedStorageTypes;\\n+ } else {\\n+ const SIZE_OF_V: u64 = __size_of::<V>();\\n+\\n+ let len = __state_preload(self.field_id()) / SIZE_OF_V;\\n+ if index > len {\\n+ panic StorageVecError::IndexOutOfBounds(OutOfBounds {\\n+ length: len,\\n+ index,\\n+ });\\n+ }\\n+\\n+ if index == len {\\n+ append_slot(self.field_id(), value);\\n+ } else {\\n+ let len_in_bytes = len * SIZE_OF_V;\\n+ let index_offset = index * SIZE_OF_V;\\n+\\n+ // 1. Get the current slot content.\\n+ let content_ptr = alloc_bytes(len_in_bytes);\\n+ let _ = __state_load_slot(self.field_id(), content_ptr, 0, len_in_bytes);\\n+\\n+ // 2. Write the `value` at `index`.\\n+ __state_update_slot(\\n+ self\\n+ .field_id(),\\n+ __addr_of::<V>(value),\\n+ index_offset,\\n+ SIZE_OF_V,\\n+ );\\n+\\n+ // 3. Write the previous content that should come after the inserted `value`.\\n+ let content_after_index_ptr = content_ptr.add::<u8>(index_offset);\\n+ let content_after_index_len = len_in_bytes - index_offset;\\n+ __state_update_slot(\\n+ self\\n+ .field_id(),\\n+ content_after_index_ptr,\\n+ index_offset + SIZE_OF_V,\\n+ content_after_index_len,\\n+ );\\n+ }\\n+ }\\n+ }\\n+\\n+ /// Returns the length of the vector.\\n+ ///\\n+ /// # Returns\\n+ ///\\n+ /// * [u64] - The length of the vector.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// ## When `V` is a Non-storage Type\\n+ ///\\n+ /// * Preloads: `1` (to get the vector's length)\\n+ ///\\n+ /// ## When `V` is a Nested Storage Type\\n+ ///\\n+ /// * Reads: `1` (to get the vector's length)\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// use std::storage::storage_vec::*;\\n+ ///\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {},\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// assert_eq(0, storage.vec.len());\\n+ /// storage.vec.push(5);\\n+ /// assert_eq(1, storage.vec.len());\\n+ /// storage.vec.push(10);\\n+ /// assert_eq(2, storage.vec.len());\\n+ /// }\\n+ /// ```\\n+ #[storage(read)]\\n+ pub fn len(self) -> u64 {\\n+ const STORES_STORAGE_TYPE: bool = __size_of::<V>() == 0;\\n+\\n+ if STORES_STORAGE_TYPE {\\n+ read_slot::<u64>(self.field_id(), 0).unwrap_or(0)\\n+ } else {\\n+ __state_preload(self.field_id()) / __size_of::<V>()\\n+ }\\n+ }\\n+\\n+ /// Returns true if the vector is empty, otherwise false.\\n+ ///\\n+ /// # Returns\\n+ ///\\n+ /// * [bool] - Indicates whether the vector is empty or not.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// ## When `V` is a Non-storage Type\\n+ ///\\n+ /// * Preloads: `1` (to get the vector's length)\\n+ ///\\n+ /// ## When `V` is a Nested Storage Type\\n+ ///\\n+ /// * Reads: `1` (to get the vector's length)\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// use std::storage::storage_vec::*;\\n+ ///\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {}\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// assert(storage.vec.is_empty());\\n+ /// storage.vec.push(5);\\n+ /// assert(!storage.vec.is_empty());\\n+ /// storage.vec.clear();\\n+ /// assert(storage.vec.is_empty());\\n+ /// }\\n+ /// ```\\n+ #[storage(read)]\\n+ pub fn is_empty(self) -> bool {\\n+ self.len() == 0\\n+ }\\n+\\n+ /// Swaps the positions of the two elements at the given indices.\\n+ ///\\n+ /// # Additional Information\\n+ ///\\n+ /// **This method is not supported for nested storage types and will panic if `V` is a nested storage type.**\\n+ ///\\n+ /// If `element1_index` and `element2_index` are equal, this method does not read from or write into the storage,\\n+ /// aside from preloading the vectors length.\\n+ ///\\n+ /// # Arguments\\n+ ///\\n+ /// * `element1_index`: [u64] - The index of the first element.\\n+ /// * `element2_index`: [u64] - The index of the second element.\\n+ ///\\n+ /// # Panics\\n+ ///\\n+ /// * `StorageVecError::IndexOutOfBounds`, if `element1_index` or `element2_index` is out of bounds.\\n+ /// * `StorageVecError::MethodDoesNotSupportNestedStorageTypes`, if `V` is a nested storage type, i.e. if it is a zero-sized type.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// * Preloads: `1` (to get the vector's length)\\n+ /// * Loads: `1` (to read current slot content when the indices differ)\\n+ /// * Writes: `1` (to write the swapped content when the indices differ)\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// use std::storage::storage_vec::*;\\n+ ///\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {}\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// storage.vec.push(5);\\n+ /// storage.vec.push(10);\\n+ /// storage.vec.push(15);\\n+ ///\\n+ /// storage.vec.swap(0, 2);\\n+ /// assert_eq(15, storage.vec.get(0).unwrap().read());\\n+ /// assert_eq(10, storage.vec.get(1).unwrap().read());\\n+ /// assert_eq(5, storage.vec.get(2).unwrap().read());\\n+ /// }\\n+ /// ```\\n+ #[storage(write)]\\n+ pub fn swap(self, element1_index: u64, element2_index: u64) {\\n+ const STORES_STORAGE_TYPE: bool = __size_of::<V>() == 0;\\n+\\n+ if STORES_STORAGE_TYPE {\\n+ // This workaround for satisfying the `#[storage]` attribute\\n+ // is explained in the comment above this `StorageVec` impl.\\n+ let _ = __state_clear(b256::zero(), 0);\\n+ panic StorageVecError::MethodDoesNotSupportNestedStorageTypes;\\n+ } else {\\n+ const SIZE_OF_V: u64 = __size_of::<V>();\\n+\\n+ let len = __state_preload(self.field_id()) / SIZE_OF_V;\\n+\\n+ if element1_index >= len {\\n+ panic StorageVecError::IndexOutOfBounds(OutOfBounds {\\n+ length: len,\\n+ index: element1_index,\\n+ });\\n+ }\\n+\\n+ if element2_index >= len {\\n+ panic StorageVecError::IndexOutOfBounds(OutOfBounds {\\n+ length: len,\\n+ index: element2_index,\\n+ });\\n+ }\\n+\\n+ if element1_index == element2_index {\\n+ return;\\n+ }\\n+\\n+ let len_in_bytes = len * SIZE_OF_V;\\n+ let element1_offset = element1_index * SIZE_OF_V;\\n+ let element2_offset = element2_index * SIZE_OF_V;\\n+\\n+ let content_ptr = alloc_bytes(len_in_bytes);\\n+ let _ = __state_load_slot(self.field_id(), content_ptr, 0, len_in_bytes);\\n+\\n+ // Copy first element to a temporary.\\n+ let element1_value_ptr = alloc_bytes(SIZE_OF_V);\\n+ content_ptr\\n+ .add::<u8>(element1_offset)\\n+ .copy_bytes_to(element1_value_ptr, SIZE_OF_V);\\n+\\n+ content_ptr\\n+ .add::<u8>(element2_offset)\\n+ .copy_bytes_to(content_ptr.add::<u8>(element1_offset), SIZE_OF_V);\\n+ element1_value_ptr.copy_bytes_to(content_ptr.add::<u8>(element2_offset), SIZE_OF_V);\\n+\\n+ __state_store_slot(self.field_id(), content_ptr, len_in_bytes);\\n+ }\\n+ }\\n+\\n+ /// Returns the first element of the vector, or `None` if it is empty.\\n+ ///\\n+ /// # Returns\\n+ ///\\n+ /// * [Option<StorageKey<V>>] - The location in storage of the value stored at\\n+ /// the start of the vector, or `None` if the vector is empty.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// * Reads: `1` (to get vector's length)\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {},\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// assert(storage.vec.first().is_none());\\n+ /// storage.vec.push(5);\\n+ /// assert_eq(5, storage.vec.first().unwrap().read());\\n+ /// }\\n+ /// ```\\n+ #[storage(read)]\\n+ pub fn first(self) -> Option<StorageKey<V>> {\\n+ let len = self.len();\\n+\\n+ if len == 0 {\\n+ return None;\\n+ }\\n+\\n+ const STORES_STORAGE_TYPE: bool = __size_of::<V>() == 0;\\n+\\n+ let field_id = if STORES_STORAGE_TYPE {\\n+ // Nested storage types are stored at a unique `field_id`\\n+ // set to `sha256((<index>, self.field_id())` to ensure every\\n+ // nested storage type element will use it and store its content\\n+ // in a different slot.\\n+ sha256((0, self.field_id()))\\n+ } else {\\n+ // For non-zero-sized types, their values are\\n+ // stored in the `self.field_id()` slot.\\n+ self.field_id()\\n+ };\\n+\\n+ Some(StorageKey::<V>::new(self.field_id(), 0, field_id))\\n+ }\\n+\\n+ /// Returns the last element of the vector, or `None` if it is empty.\\n+ ///\\n+ /// # Returns\\n+ ///\\n+ /// * [Option<StorageKey<V>>] - The location in storage of the value stored at\\n+ /// the end of the vector, or `None` if the vector is empty.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// * Reads: `1` (to get vector's length)\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {},\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// assert(storage.vec.last().is_none());\\n+ /// storage.vec.push(5);\\n+ /// storage.vec.push(10);\\n+ /// assert_eq(10, storage.vec.last().unwrap().read());\\n+ /// }\\n+ /// ```\\n+ #[storage(read)]\\n+ pub fn last(self) -> Option<StorageKey<V>> {\\n+ let len = self.len();\\n+\\n+ if len == 0 {\\n+ return None;\\n+ }\\n+\\n+ const STORES_STORAGE_TYPE: bool = __size_of::<V>() == 0;\\n+\\n+ let (offset, field_id) = if STORES_STORAGE_TYPE {\\n+ // Nested storage types are stored at a unique `field_id`\\n+ // set to `sha256((<index>, self.field_id())` to ensure every\\n+ // nested storage type element will use it and store its content\\n+ // in a different slot.\\n+ (0, sha256((len - 1, self.field_id())))\\n+ } else {\\n+ // For non-zero-sized types, their values are\\n+ // stored in the `self.field_id()` slot.\\n+ ((len - 1) * __size_of::<V>(), self.field_id())\\n+ };\\n+\\n+ Some(StorageKey::<V>::new(self.field_id(), offset, field_id))\\n+ }\\n+\\n+ /// Reverses the order of elements in the vector, in place.\\n+ ///\\n+ /// # Additional Information\\n+ ///\\n+ /// **This method is not supported for nested storage types and will panic if `V` is a nested storage type.**\\n+ ///\\n+ /// # Panics\\n+ ///\\n+ /// * `StorageVecError::MethodDoesNotSupportNestedStorageTypes`, if `V` is a nested storage type, i.e. if it is a zero-sized type.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// * Preloads: `1` (to get vector's length)\\n+ /// * Loads: `1` when `self.len() >= 2`, otherwise `0`\\n+ /// * Writes: `1` when `self.len() >= 2`, otherwise `0`\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {},\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// storage.vec.push(5);\\n+ /// storage.vec.push(10);\\n+ /// storage.vec.push(15);\\n+ ///\\n+ /// storage.vec.reverse();\\n+ ///\\n+ /// assert_eq(15, storage.vec.get(0).unwrap().read());\\n+ /// assert_eq(10, storage.vec.get(1).unwrap().read());\\n+ /// assert_eq(5, storage.vec.get(2).unwrap().read());\\n+ /// }\\n+ /// ```\\n+ #[storage(write)]\\n+ pub fn reverse(self) {\\n+ const STORES_STORAGE_TYPE: bool = __size_of::<V>() == 0;\\n+\\n+ if STORES_STORAGE_TYPE {\\n+ // This workaround for satisfying the `#[storage]` attribute\\n+ // is explained in the comment above this `StorageVec` impl.\\n+ let _ = __state_clear(b256::zero(), 0);\\n+ panic StorageVecError::MethodDoesNotSupportNestedStorageTypes;\\n+ } else {\\n+ const SIZE_OF_V: u64 = __size_of::<V>();\\n+\\n+ let len = __state_preload(self.field_id()) / SIZE_OF_V;\\n+\\n+ if len < 2 {\\n+ return;\\n+ }\\n+\\n+ let len_in_bytes = len * SIZE_OF_V;\\n+ let content_ptr = alloc_bytes(len_in_bytes);\\n+ let _ = __state_load_slot(self.field_id(), content_ptr, 0, len_in_bytes);\\n+\\n+ // Allocate a temporary for swaps.\\n+ let tmp_ptr = alloc_bytes(SIZE_OF_V);\\n+\\n+ let mid = len / 2;\\n+ let mut i = 0;\\n+ while i < mid {\\n+ let left_offset = i * SIZE_OF_V;\\n+ let right_offset = (len - i - 1) * SIZE_OF_V;\\n+\\n+ // tmp <- left.\\n+ content_ptr.add::<u8>(left_offset).copy_bytes_to(tmp_ptr, SIZE_OF_V);\\n+\\n+ // right -> left.\\n+ content_ptr\\n+ .add::<u8>(right_offset)\\n+ .copy_bytes_to(content_ptr.add::<u8>(left_offset), SIZE_OF_V);\\n+\\n+ // tmp -> right.\\n+ tmp_ptr.copy_bytes_to(content_ptr.add::<u8>(right_offset), SIZE_OF_V);\\n+\\n+ i += 1;\\n+ }\\n+\\n+ __state_store_slot(self.field_id(), content_ptr, len_in_bytes);\\n+ }\\n+ }\\n+\\n+ /// Replaces all elements in the vector with `value`.\\n+ ///\\n+ /// # Additional Information\\n+ ///\\n+ /// **This method is not supported for nested storage types and will panic if `V` is a nested storage type.**\\n+ ///\\n+ /// # Arguments\\n+ ///\\n+ /// * `value`: [V] - Value to copy to each element of the vector.\\n+ ///\\n+ /// # Panics\\n+ ///\\n+ /// * `StorageVecError::MethodDoesNotSupportNestedStorageTypes`, if `V` is a nested storage type, i.e. if it is a zero-sized type.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// * Preloads: `1` (to get vector's length)\\n+ /// * Writes: `1` if `self.len() > 0`, otherwise `0`\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {},\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// storage.vec.push(5);\\n+ /// storage.vec.push(10);\\n+ /// storage.vec.push(15);\\n+\\n+ /// storage.vec.fill(20);\\n+ ///\\n+ /// assert_eq(20, storage.vec.get(0).unwrap().read());\\n+ /// assert_eq(20, storage.vec.get(1).unwrap().read());\\n+ /// assert_eq(20, storage.vec.get(2).unwrap().read());\\n+ /// }\\n+ /// ```\\n+ #[storage(write)]\\n+ pub fn fill(self, value: V) {\\n+ const STORES_STORAGE_TYPE: bool = __size_of::<V>() == 0;\\n+\\n+ if STORES_STORAGE_TYPE {\\n+ // This workaround for satisfying the `#[storage]` attribute\\n+ // is explained in the comment above this `StorageVec` impl.\\n+ let _ = __state_clear(b256::zero(), 0);\\n+ panic StorageVecError::MethodDoesNotSupportNestedStorageTypes;\\n+ } else {\\n+ const SIZE_OF_V: u64 = __size_of::<V>();\\n+\\n+ let len = __state_preload(self.field_id()) / SIZE_OF_V;\\n+\\n+ if len == 0 {\\n+ return;\\n+ }\\n+\\n+ let len_in_bytes = len * SIZE_OF_V;\\n+ let content_ptr = alloc_bytes(len_in_bytes);\\n+\\n+ let value_ptr = __addr_of::<V>(value);\\n+\\n+ let mut i = 0;\\n+ while i < len {\\n+ value_ptr.copy_bytes_to(content_ptr.add::<u8>(i * SIZE_OF_V), SIZE_OF_V);\\n+ i += 1;\\n+ }\\n+\\n+ __state_store_slot(self.field_id(), content_ptr, len_in_bytes);\\n+ }\\n+ }\\n+\\n+ /// Resizes `self` in place so that `len` is equal to `new_len`.\\n+ ///\\n+ /// # Additional Information\\n+ ///\\n+ /// If `new_len` is greater than `len`, `self` is extended by the difference, with each\\n+ /// additional element being set to `value`. If the `new_len` is less than `len`, `self` is\\n+ /// simply truncated.\\n+ ///\\n+ /// > **_WARNING:_** **If `V` is a nested storage type and `new_len` is less than `len`,\\n+ /// `resize` will reduce the vector length and remove the remaining elements _from the vector_,\\n+ /// but the nested content of those removed elements will remind in the storage.**\",\n \"resolving_sha\": \"ecc2c92ea28c187e76d47f70d6de0024c884c202\",\n \"resolving_diff\": \"diff --git a/sway-lib-std/src/storage/storage_vec.sw b/sway-lib-std/src/storage/storage_vec.sw\\nindex c1c2073fdd9..369b7de24dc 100644\\n--- a/sway-lib-std/src/storage/storage_vec.sw\\n+++ b/sway-lib-std/src/storage/storage_vec.sw\\n@@ -10,14 +10,89 @@ use ::vec::Vec;\\n use ::iterator::Iterator;\\n use ::codec::*;\\n use ::debug::*;\\n+use ::marker::*;\\n+\\n+/// Describes an out-of-bounds `StorageVec` access.\\n+pub struct OutOfBounds {\\n+ /// The length of the `StorageVec`.\\n+ pub length: u64,\\n+ /// The index that was out-of-bounds.\\n+ /// `index` is always greater than or equal to `length`.\\n+ pub index: u64,\\n+}\\n+\\n+/// The error type used by `StorageVec<T>` methods.\\n+#[error_type]\\n+pub enum StorageVecError {\\n+ /// Index was out of bounds.\\n+ #[error(m = \\\"Index was out of bounds.\\\")]\\n+ IndexOutOfBounds: OutOfBounds,\\n+ /// Called `StorageVec<T>` method does not support `T` being a nested storage type (a zero-sized type in general).\\n+ #[error(m = \\\"Called `StorageVec<T>` method does not support `T` being a nested storage type (a zero-sized type in general).\\\")]\\n+ MethodDoesNotSupportNestedStorageTypes: (),\\n+}\\n \\n-/// A persistent vector struct.\\n+/// A storage type for storing a vector of elements of type `V`.\\n+///\\n+/// `StorageVec` can contain storage types and can be contained\\n+/// in storage types. E.g.:\\n+/// - `StorageVec<StorageVec<u64>>`\\n+/// - `StorageVec<StorageMap<u64, b256>>`\\n+/// - `StorageMap<u64, StorageVec<b256>>`\\n+///\\n+/// **Some `StorageVec` methods are not supported for\\n+/// nested storage types and will revert if used with nested\\n+/// storage types.** E.g., `StorageVec<StorageString>::remove`\\n+/// will revert.\\n+///\\n+/// **Some `StorageVec` methods can have limitations and exceptional\\n+/// behaviors when used with nested storage types.\\n+/// E.g., `StorageVec<StorageString>::pop` will pop the last element,\\n+/// but it will always return `None` and the `StorageString` will not\\n+/// be removed from the storage.\\n+///\\n+/// To see if some `StorageVec` method is supported for nested storage types\\n+/// at all, or if it has any limitations or exceptional behavior,\\n+/// refer to method documentation.\\n #[cfg(experimental_dynamic_storage = false)]\\n pub struct StorageVec<V> {}\\n \\n+/// A storage type for storing a vector of elements of type `V`.\\n+///\\n+/// `StorageVec` can contain storage types and can be contained\\n+/// in storage types. E.g.:\\n+/// - `StorageVec<StorageVec<u64>>`\\n+/// - `StorageVec<StorageMap<u64, b256>>`\\n+/// - `StorageMap<u64, StorageVec<b256>>`\\n+///\\n+/// **Some `StorageVec` methods are not supported for\\n+/// nested storage types and will panic if used with nested\\n+/// storage types.** E.g., `StorageVec<StorageString>::remove`\\n+/// will panic with `StorageVecError::MethodDoesNotSupportNestedStorageTypes`.\\n+///\\n+/// **Some `StorageVec` methods can have limitations and exceptional\\n+/// behaviors when used with nested storage types.**\\n+/// E.g., `StorageVec<StorageString>::pop` will pop the last element,\\n+/// but it will always return `None` and the `StorageString` will not\\n+/// be removed from the storage.\\n+///\\n+/// To see if some `StorageVec` method is supported for nested storage types\\n+/// at all, or if it has any limitations or exceptional behaviors,\\n+/// refer to method documentation.\\n+#[cfg(experimental_dynamic_storage = true)]\\n+pub struct StorageVec<V> {}\\n+\\n+// Note: `StorageVec` is a zero-sized storage type that can be nested\\n+// within other storage types. For example, a `StorageMap<K, StorageVec>`.\\n+// That's why we **always use the `self.field_id`** as a storage slot\\n+// for all of the methods of `StorageVec`, and **never the `self.slot`**.\\n+\\n+// In the quads-based `StorageVec` the `self.field_id`\\n+// stores the vector's length, while the actual content is stored\\n+// at the `sha256(self.field_id)`.\\n #[cfg(experimental_dynamic_storage = false)]\\n impl<V> StorageKey<StorageVec<V>> {\\n- /// Appends the value to the end of the vector.\\n+ /// Appends `value` to the end of the vector.\\n ///\\n /// # Arguments\\n ///\\n@@ -34,33 +109,48 @@ impl<V> StorageKey<StorageVec<V>> {\\n /// use std::storage::storage_vec::*;\\n ///\\n /// storage {\\n- /// vec: StorageVec<u64> = StorageVec {}\\n+ /// vec: StorageVec<u64> = StorageVec {},\\n+ /// vec_of_vec: StorageVec<StorageVec<u64>> = StorageVec {},\\n /// }\\n ///\\n /// fn foo() {\\n /// let five = 5_u64;\\n /// storage.vec.push(five);\\n- /// assert(five == storage.vec.get(0).unwrap().read());\\n+ /// assert_eq(five, storage.vec.get(0).unwrap().read());\\n+ ///\\n+ /// storage.vec_of_vec.push(StorageVec {});\\n+ /// assert_eq(0, storage.vec_of_vec.get(0).unwrap().len());\\n /// }\\n /// ```\\n #[storage(read, write)]\\n pub fn push(self, value: V) {\\n let len = read_quads::<u64>(self.field_id(), 0).unwrap_or(0);\\n \\n- // Storing the value at the current length index (if this is the first item, starts off at 0)\\n+ // Storing the value at the current length index\\n+ // (if this is the first item, starts off at 0).\\n let key = sha256(self.field_id());\\n let offset = offset_calculator::<V>(len);\\n write_quads::<V>(key, offset, value);\\n \\n- // Incrementing the length\\n+ // Incrementing the length.\\n write_quads(self.field_id(), 0, len + 1);\\n }\\n \\n- /// Removes the last element of the vector and returns it, `None` if empty.\\n+ /// Removes the last element of the vector and returns it, or `None` if the vector is empty,\\n+ /// or it contains a nested storage type.\\n+ ///\\n+ /// # Additional Information\\n+ ///\\n+ /// **If `V` is a nested storage type, `pop` always returns `None`, even if the vector is not\\n+ /// empty and the last element got removed.**\\n+ ///\\n+ /// > **_WARNING:_** **If `V` is a nested storage type, `pop` will reduce the vector length and\\n+ /// remove the last element _from the vector_, but the nested content of the removed element\\n+ /// will remain in the storage.**\\n ///\\n /// # Returns\\n ///\\n- /// * [Option<V>] - The last element `V` or `None`.\\n+ /// * [Option<V>] - The last element of the vector, or `None` if the vector is empty, or it contains a nested storage type.\\n ///\\n /// # Number of Storage Accesses\\n ///\\n@@ -73,14 +163,14 @@ impl<V> StorageKey<StorageVec<V>> {\\n /// use std::storage::storage_vec::*;\\n ///\\n /// storage {\\n- /// vec: StorageVec<u64> = StorageVec {}\\n+ /// vec: StorageVec<u64> = StorageVec {},\\n /// }\\n ///\\n /// fn foo() {\\n /// let five = 5_u64;\\n /// storage.vec.push(five);\\n /// let popped_value = storage.vec.pop().unwrap();\\n- /// assert(five == popped_value);\\n+ /// assert_eq(five, popped_value);\\n /// let none_value = storage.vec.pop();\\n /// assert(none_value.is_none());\\n /// }\\n@@ -89,12 +179,11 @@ impl<V> StorageKey<StorageVec<V>> {\\n pub fn pop(self) -> Option<V> {\\n let len = read_quads::<u64>(self.field_id(), 0).unwrap_or(0);\\n \\n- // if the length is 0, there is no item to pop from the vec\\n if len == 0 {\\n return None;\\n }\\n \\n- // reduces len by 1, effectively removing the last item in the vec\\n+ // Reducing len by 1, effectively removing the last item in the vec.\\n write_quads(self.field_id(), 0, len - 1);\\n \\n let key = sha256(self.field_id());\\n@@ -102,16 +191,15 @@ impl<V> StorageKey<StorageVec<V>> {\\n read_quads::<V>(key, offset)\\n }\\n \\n- /// Gets the value in the given index, `None` if index is out of bounds.\\n+ /// Gets the value at the given `index` or `None` if `index` is out of bounds.\\n ///\\n /// # Arguments\\n ///\\n- /// * `index`: [u64] - The index of the vec to retrieve the item from.\\n+ /// * `index`: [u64] - The index to retrieve the item from.\\n ///\\n /// # Returns\\n ///\\n- /// * [Option<StorageKey<V>>] - Describes the raw location in storage of the value stored at\\n- /// `key` or `None` if out of bounds.\\n+ /// * [Option<StorageKey<V>>] - Location in storage of the value stored at `index` or `None` if `index` is out of bounds.\\n ///\\n /// # Number of Storage Accesses\\n ///\\n@@ -129,7 +217,7 @@ impl<V> StorageKey<StorageVec<V>> {\\n /// fn foo() {\\n /// let five = 5_u64;\\n /// storage.vec.push(five);\\n- /// assert(five == storage.vec.get(0).unwrap().read());\\n+ /// assert_eq(five, storage.vec.get(0).unwrap().read());\\n /// assert(storage.vec.get(1).is_none());\\n /// }\\n /// ```\\n@@ -137,37 +225,40 @@ impl<V> StorageKey<StorageVec<V>> {\\n pub fn get(self, index: u64) -> Option<StorageKey<V>> {\\n let len = read_quads::<u64>(self.field_id(), 0).unwrap_or(0);\\n \\n- // if the index is larger or equal to len, there is no item to return\\n if len <= index {\\n return None;\\n }\\n \\n let key = sha256(self.field_id());\\n let offset = offset_calculator::<V>(index);\\n- // This StorageKey can be read by the standard storage api.\\n- // Field Id must be unique such that nested storage vecs work as they have a\\n- // __size_of() zero and will therefore always have an offset of zero.\\n+\\n+ // This `StorageKey` can be read by the standard storage API.\\n+ // Note that it has a unique `field_id` set to `sha256((index, key))`,\\n+ // to support nested storage types that will use that value.\\n Some(StorageKey::<V>::new(key, offset, sha256((index, key))))\\n }\\n \\n- /// Removes the element in the given index and moves all the elements in the following indexes\\n- /// down one index. Also returns the element.\\n+ /// Removes the element at the given `index` and moves all the elements at the following indices\\n+ /// down one index. Returns the removed element.\\n ///\\n /// # Additional Information\\n ///\\n- /// **_WARNING:_** Expensive for larger vecs.\\n+ /// **This method is not supported for nested storage types and will revert if `V` is a nested storage type.**\\n+ ///\\n+ /// > **_WARNING:_** Gas consuming for larger vectors.\\n ///\\n /// # Arguments\\n ///\\n- /// * `index`: [u64] - The index of the vec to remove the item from.\\n+ /// * `index`: [u64] - The index to remove the element from.\\n ///\\n /// # Returns\\n ///\\n- /// * [V] - The element that has been removed at the index.\\n+ /// * [V] - The removed element.\\n ///\\n /// # Reverts\\n ///\\n- /// * Reverts if index is larger or equal to length of the vec.\\n+ /// * If `index` is out of bounds.\\n+ /// * If `V` is a nested storage type, i.e. if it is a zero-sized type.\\n ///\\n /// # Number of Storage Accesses\\n ///\\n@@ -188,15 +279,16 @@ impl<V> StorageKey<StorageVec<V>> {\\n /// storage.vec.push(10);\\n /// storage.vec.push(15);\\n /// let removed_value = storage.vec.remove(1);\\n- /// assert(10 == removed_value);\\n- /// assert(storage.vec.len() == 2);\\n+ /// assert_eq(10, removed_value);\\n+ /// assert_eq(storage.vec.len(), 2);\\n /// }\\n /// ```\\n #[storage(read, write)]\\n pub fn remove(self, index: u64) -> V {\\n+ assert(__size_of::<V>() > 0);\\n+\\n let len = read_quads::<u64>(self.field_id(), 0).unwrap_or(0);\\n \\n- // if the index is larger or equal to len, there is no item to remove\\n assert(index < len);\\n \\n // gets the element before removing it, so it can be returned\\n@@ -228,20 +320,27 @@ impl<V> StorageKey<StorageVec<V>> {\\n removed_element\\n }\\n \\n- /// Removes the element at the specified index and fills it with the last element.\\n- /// This does not preserve ordering and returns the element.\\n+ /// Replaces the element at the given `index` with the last element, and removes the last element.\\n+ /// Returns the replaced element.\\n+ ///\\n+ /// # Additional Information\\n+ ///\\n+ /// **This method is not supported for nested storage types and will revert if `V` is a nested storage type.**\\n+ ///\\n+ /// If `index` is the index of the last element, the last element will be returned and removed from the vector.\\n ///\\n /// # Arguments\\n ///\\n- /// * `index`: [u64] - The index of the vec to remove the item from.\\n+ /// * `index`: [u64] - The index at which to replace the element with the last element.\\n ///\\n /// # Returns\\n ///\\n- /// * [V] - The element that has been removed at the index.\\n+ /// * [V] - The replaced element.\\n ///\\n /// # Reverts\\n ///\\n- /// * Reverts if index is larger or equal to length of the vec.\\n+ /// * If `index` is out of bounds.\\n+ /// * If `V` is a nested storage type, i.e. if it is a zero-sized type.\\n ///\\n /// # Number of Storage Accesses\\n ///\\n@@ -262,16 +361,18 @@ impl<V> StorageKey<StorageVec<V>> {\\n /// storage.vec.push(10);\\n /// storage.vec.push(15);\\n /// let removed_value = storage.vec.swap_remove(0);\\n- /// assert(5 == removed_value);\\n+ /// assert_eq(5, removed_value);\\n /// let swapped_value = storage.vec.get(0).unwrap().read();\\n- /// assert(15 == swapped_value);\\n+ /// assert_eq(15, swapped_value); // The first element is replaced by the last element.\\n+ /// assert_eq(2, vec.len()); // The last element is removed.\\n /// }\\n /// ```\\n #[storage(read, write)]\\n pub fn swap_remove(self, index: u64) -> V {\\n+ assert(__size_of::<V>() > 0);\\n+\\n let len = read_quads::<u64>(self.field_id(), 0).unwrap_or(0);\\n \\n- // if the index is larger or equal to len, there is no item to remove\\n assert(index < len);\\n \\n let key = sha256(self.field_id());\\n@@ -290,20 +391,25 @@ impl<V> StorageKey<StorageVec<V>> {\\n element_to_be_removed\\n }\\n \\n- /// Sets or mutates the value at the given index.\\n+ /// Sets the `value` at the given `index`.\\n+ ///\\n+ /// # Additional Information\\n+ ///\\n+ /// **This method is not supported for nested storage types and will revert if `V` is a nested storage type.**\\n ///\\n /// # Arguments\\n ///\\n- /// * `index`: [u64] - The index of the vec to set the value at\\n- /// * `value`: [V] - The value to be set\\n+ /// * `index`: [u64] - The index to set the value at.\\n+ /// * `value`: [V] - The value to be set.\\n ///\\n /// # Reverts\\n ///\\n- /// * Reverts if index is larger than or equal to the length of the vec.\\n+ /// * If `index` is out of bounds.\\n+ /// * If `V` is a nested storage type, i.e. if it is a zero-sized type.\\n ///\\n /// # Number of Storage Accesses\\n ///\\n- /// * Reads: `2`\\n+ /// * Reads: `1` or `2` (`1` to get vector's length, and `0` if the `value` occupies full slots, or `1` otherwise to read the existing data that will be partially overwritten)\\n /// * Writes: `1`\\n ///\\n /// # Examples\\n@@ -318,18 +424,18 @@ impl<V> StorageKey<StorageVec<V>> {\\n /// fn foo() {\\n /// storage.vec.push(5);\\n /// storage.vec.push(10);\\n- /// storage.vec.push(15);\\n ///\\n- /// storage.vec.set(0, 20);\\n+ /// storage.vec.set(0, 15);\\n /// let set_value = storage.vec.get(0).unwrap().read();\\n- /// assert(20 == set_value);\\n+ /// assert_eq(15, set_value);\\n /// }\\n /// ```\\n #[storage(read, write)]\\n pub fn set(self, index: u64, value: V) {\\n+ assert(__size_of::<V>() > 0);\\n+\\n let len = read_quads::<u64>(self.field_id(), 0).unwrap_or(0);\\n \\n- // if the index is higher than or equal len, there is no element to set\\n assert(index < len);\\n \\n let key = sha256(self.field_id());\\n@@ -337,21 +443,27 @@ impl<V> StorageKey<StorageVec<V>> {\\n write_quads::<V>(key, offset, value);\\n }\\n \\n- /// Inserts the value at the given index, moving the current index's value\\n- /// as well as the following index's value up by one index.\\n+ /// Inserts the `value` at the given `index`, moving the current value at `index`\\n+ /// as well as the following indices up by one index.\\n ///\\n /// # Additional Information\\n ///\\n- /// > **_WARNING:_** Expensive for larger vecs.\\n+ /// **This method is not supported for nested storage types and will revert if `V` is a nested storage type.**\\n+ ///\\n+ /// If `index` is equal to vector's length, appends the `value` at the end of the\\n+ /// vector, effectively acting the same as `push`.\\n+ ///\\n+ /// > **_WARNING:_** Gas consuming for larger vectors.\\n ///\\n /// # Arguments\\n ///\\n- /// * `index`: [u64] - The index of the vec to insert the item into.\\n- /// * `value`: [V] - The value to insert into the vec.\\n+ /// * `index`: [u64] - The index to insert the value into.\\n+ /// * `value`: [V] - The value to insert.\\n ///\\n /// # Reverts\\n ///\\n- /// * Reverts if index is larger than the length of the vec.\\n+ /// * If `index` is larger than the length of the vector.\\n+ /// * If `V` is a nested storage type, i.e. if it is a zero-sized type.\\n ///\\n /// # Number of Storage Accesses\\n ///\\n@@ -373,16 +485,17 @@ impl<V> StorageKey<StorageVec<V>> {\\n ///\\n /// storage.vec.insert(1, 10);\\n ///\\n- /// assert(5 == storage.vec.get(0).unwrap().read());\\n- /// assert(10 == storage.vec.get(1).unwrap().read());\\n- /// assert(15 == storage.vec.get(2).unwrap().read());\\n+ /// assert_eq(5, storage.vec.get(0).unwrap().read());\\n+ /// assert_eq(10, storage.vec.get(1).unwrap().read());\\n+ /// assert_eq(15, storage.vec.get(2).unwrap().read());\\n /// }\\n /// ```\\n #[storage(read, write)]\\n pub fn insert(self, index: u64, value: V) {\\n+ assert(__size_of::<V>() > 0);\\n+\\n let len = read_quads::<u64>(self.field_id(), 0).unwrap_or(0);\\n \\n- // if the index is larger than len, there is no space to insert\\n assert(index <= len);\\n \\n // if len is 0, index must also be 0 due to above check\\n@@ -430,7 +543,7 @@ impl<V> StorageKey<StorageVec<V>> {\\n ///\\n /// # Returns\\n ///\\n- /// * [u64] - The stored length of the vector.\\n+ /// * [u64] - The length of the vector.\\n ///\\n /// # Number of Storage Accesses\\n ///\\n@@ -442,15 +555,15 @@ impl<V> StorageKey<StorageVec<V>> {\\n /// use std::storage::storage_vec::*;\\n ///\\n /// storage {\\n- /// vec: StorageVec<u64> = StorageVec {}\\n+ /// vec: StorageVec<u64> = StorageVec {},\\n /// }\\n ///\\n /// fn foo() {\\n- /// assert(0 == storage.vec.len());\\n+ /// assert_eq(0, storage.vec.len());\\n /// storage.vec.push(5);\\n- /// assert(1 == storage.vec.len());\\n+ /// assert_eq(1, storage.vec.len());\\n /// storage.vec.push(10);\\n- /// assert(2 == storage.vec.len());\\n+ /// assert_eq(2, storage.vec.len());\\n /// }\\n /// ```\\n #[storage(read)]\\n@@ -458,15 +571,15 @@ impl<V> StorageKey<StorageVec<V>> {\\n read_quads::<u64>(self.field_id(), 0).unwrap_or(0)\\n }\\n \\n- /// Checks whether the len is zero or not.\\n+ /// Returns true if the vector is empty, otherwise false.\\n ///\\n /// # Returns\\n ///\\n- /// * [bool] - Indicates whether the vector is or is not empty.\\n+ /// * [bool] - Indicates whether the vector is empty or not.\\n ///\\n /// # Number of Storage Accesses\\n ///\\n- /// * Reads: `1`\\n+ /// * Reads: `1` (to get vector's length)\\n ///\\n /// # Examples\\n ///\\n@@ -478,15 +591,11 @@ impl<V> StorageKey<StorageVec<V>> {\\n /// }\\n ///\\n /// fn foo() {\\n- /// assert(true == storage.vec.is_empty());\\n- ///\\n+ /// assert(storage.vec.is_empty());\\n /// storage.vec.push(5);\\n- ///\\n- /// assert(false == storage.vec.is_empty());\\n- ///\\n+ /// assert(!storage.vec.is_empty());\\n /// storage.vec.clear();\\n- ///\\n- /// assert(true == storage.vec.is_empty());\\n+ /// assert(storage.vec.is_empty());\\n /// }\\n /// ```\\n #[storage(read)]\\n@@ -494,7 +603,11 @@ impl<V> StorageKey<StorageVec<V>> {\\n read_quads::<u64>(self.field_id(), 0).unwrap_or(0) == 0\\n }\\n \\n- /// Swaps two elements.\\n+ /// Swaps the positions of the two elements at the given indices.\\n+ ///\\n+ /// # Additional Information\\n+ ///\\n+ /// **This method is not supported for nested storage types and will revert if `V` is a nested storage type.**\\n ///\\n /// # Arguments\\n ///\\n@@ -503,7 +616,8 @@ impl<V> StorageKey<StorageVec<V>> {\\n ///\\n /// # Reverts\\n ///\\n- /// * If `element1_index` or `element2_index` is greater than the length of the vector.\\n+ /// * If `element1_index` or `element2_index` is out of bounds.\\n+ /// * If `V` is a nested storage type, i.e. if it is a zero-sized type.\\n ///\\n /// # Number of Storage Accesses\\n ///\\n@@ -525,12 +639,14 @@ impl<V> StorageKey<StorageVec<V>> {\\n /// storage.vec.push(15);\\n ///\\n /// storage.vec.swap(0, 2);\\n- /// assert(15 == storage.vec.get(0).unwrap().read());\\n- /// assert(10 == storage.vec.get(1).unwrap().read());\\n- /// assert(5 == storage.vec.get(2).unwrap().read());\\n+ /// assert_eq(15, storage.vec.get(0).unwrap().read());\\n+ /// assert_eq(10, storage.vec.get(1).unwrap().read());\\n+ /// assert_eq(5, storage.vec.get(2).unwrap().read());\\n /// ```\\n #[storage(read, write)]\\n pub fn swap(self, element1_index: u64, element2_index: u64) {\\n+ assert(__size_of::<V>() > 0);\\n+\\n let len = read_quads::<u64>(self.field_id(), 0).unwrap_or(0);\\n assert(element1_index < len);\\n assert(element2_index < len);\\n@@ -558,12 +674,12 @@ impl<V> StorageKey<StorageVec<V>> {\\n ///\\n /// # Returns\\n ///\\n- /// * [Option<StorageKey<V>>] - Describes the raw location in storage of the value stored at\\n- /// the start of the vector or zero if the vector is empty.\\n+ /// * [Option<StorageKey<V>>] - The location in storage of the value stored at\\n+ /// the start of the vector, or `None` if the vector is empty.\\n ///\\n /// # Number of Storage Accesses\\n ///\\n- /// * Reads: `1`\\n+ /// * Reads: `1` (to get vector's length)\\n ///\\n /// # Examples\\n ///\\n@@ -574,10 +690,8 @@ impl<V> StorageKey<StorageVec<V>> {\\n ///\\n /// fn foo() {\\n /// assert(storage.vec.first().is_none());\\n- ///\\n /// storage.vec.push(5);\\n- ///\\n- /// assert(5 == storage.vec.first().unwrap().read());\\n+ /// assert_eq(5, storage.vec.first().unwrap().read());\\n /// }\\n /// ```\\n #[storage(read)]\\n@@ -593,12 +707,12 @@ impl<V> StorageKey<StorageVec<V>> {\\n ///\\n /// # Returns\\n ///\\n- /// * [Option<StorageKey<V>>] - Describes the raw location in storage of the value stored at\\n- /// the end of the vector or zero if the vector is empty.\\n+ /// * [Option<StorageKey<V>>] - The location in storage of the value stored at\\n+ /// the end of the vector, or `None` if the vector is empty.\\n ///\\n /// # Number of Storage Accesses\\n ///\\n- /// * Reads: `1`\\n+ /// * Reads: `1` (to get vector's length)\\n ///\\n /// # Examples\\n ///\\n@@ -609,11 +723,9 @@ impl<V> StorageKey<StorageVec<V>> {\\n ///\\n /// fn foo() {\\n /// assert(storage.vec.last().is_none());\\n- ///\\n /// storage.vec.push(5);\\n /// storage.vec.push(10);\\n- ///\\n- /// assert(10 == storage.vec.last().unwrap().read());\\n+ /// assert_eq(10, storage.vec.last().unwrap().read());\\n /// }\\n /// ```\\n #[storage(read)]\\n@@ -630,6 +742,10 @@ impl<V> StorageKey<StorageVec<V>> {\\n \\n /// Reverses the order of elements in the vector, in place.\\n ///\\n+ /// # Additional Information\\n+ ///\\n+ /// **This method is not supported for nested storage types and will panic if `V` is a nested storage type.**\\n+ ///\\n /// # Number of Storage Accesses\\n ///\\n /// * Reads: `1 + (3 * (self.len() / 2))`\\n@@ -646,15 +762,18 @@ impl<V> StorageKey<StorageVec<V>> {\\n /// storage.vec.push(5);\\n /// storage.vec.push(10);\\n /// storage.vec.push(15);\\n+ ///\\n /// storage.vec.reverse();\\n ///\\n- /// assert(15 == storage.vec.get(0).unwrap().read());\\n- /// assert(10 == storage.vec.get(1).unwrap().read());\\n- /// assert(5 == storage.vec.get(2).unwrap().read());\\n+ /// assert_eq(15, storage.vec.get(0).unwrap().read());\\n+ /// assert_eq(10, storage.vec.get(1).unwrap().read());\\n+ /// assert_eq(5, storage.vec.get(2).unwrap().read());\\n /// }\\n /// ```\\n #[storage(read, write)]\\n pub fn reverse(self) {\\n+ assert(__size_of::<V>() > 0);\\n+\\n let len = read_quads::<u64>(self.field_id(), 0).unwrap_or(0);\\n \\n if len < 2 {\\n@@ -677,12 +796,20 @@ impl<V> StorageKey<StorageVec<V>> {\\n }\\n }\\n \\n- /// Fills `self` with elements by cloning `value`.\\n+ /// Replaces all elements in the vector with `value`.\\n+ ///\\n+ /// # Additional Information\\n+ ///\\n+ /// **This method is not supported for nested storage types and will revert if `V` is a nested storage type.**\\n ///\\n /// # Arguments\\n ///\\n /// * `value`: [V] - Value to copy to each element of the vector.\\n ///\\n+ /// # Reverts\\n+ ///\\n+ /// * If `V` is a nested storage type, i.e. if it is a zero-sized type.\\n+ ///\\n /// # Number of Storage Accesses\\n ///\\n /// * Reads: `1 + self.len()`\\n@@ -699,15 +826,18 @@ impl<V> StorageKey<StorageVec<V>> {\\n /// storage.vec.push(5);\\n /// storage.vec.push(10);\\n /// storage.vec.push(15);\\n+ ///\\n /// storage.vec.fill(20);\\n ///\\n- /// assert(20 == storage.vec.get(0).unwrap().read());\\n- /// assert(20 == storage.vec.get(1).unwrap().read());\\n- /// assert(20 == storage.vec.get(2).unwrap().read());\\n+ /// assert_eq(20, storage.vec.get(0).unwrap().read());\\n+ /// assert_eq(20, storage.vec.get(1).unwrap().read());\\n+ /// assert_eq(20, storage.vec.get(2).unwrap().read());\\n /// }\\n /// ```\\n #[storage(read, write)]\\n pub fn fill(self, value: V) {\\n+ assert(__size_of::<V>() > 0);\\n+\\n let len = read_quads::<u64>(self.field_id(), 0).unwrap_or(0);\\n \\n let key = sha256(self.field_id());\\n@@ -724,13 +854,17 @@ impl<V> StorageKey<StorageVec<V>> {\\n /// # Additional Information\\n ///\\n /// If `new_len` is greater than `len`, `self` is extended by the difference, with each\\n- /// additional slot being filled with `value`. If the `new_len` is less than `len`, `self` is\\n+ /// additional element being set to `value`. If the `new_len` is less than `len`, `self` is\\n /// simply truncated.\\n ///\\n+ /// > **_WARNING:_** **If `V` is a nested storage type and `new_len` is less than `len`,\\n+ /// `resize` will reduce the vector length and remove the remaining elements _from the vector_,\\n+ /// but the nested content of those removed elements will remain in the storage.**\\n+ ///\\n /// # Arguments\\n ///\\n- /// * `new_len`: [u64] - The new length to expand or truncate to\\n- /// * `value`: [V] - The value to fill into new slots if the `new_len` is greater than the current length\\n+ /// * `new_len`: [u64] - The new length to expand or truncate to.\\n+ /// * `value`: [V] - The value to set new elements to, if the `new_len` is greater than the current length.\\n ///\\n /// # Number of Storage Accesses\\n ///\\n@@ -747,19 +881,20 @@ impl<V> StorageKey<StorageVec<V>> {\\n /// fn foo() {\\n /// storage.vec.push(5);\\n /// storage.vec.push(10);\\n+ ///\\n /// storage.vec.resize(4, 20);\\n ///\\n- /// assert(5 == storage.vec.get(0).unwrap().read());\\n- /// assert(10 == storage.vec.get(1).unwrap().read());\\n- /// assert(20 == storage.vec.get(2).unwrap().read());\\n- /// assert(20 == storage.vec.get(3).unwrap().read());\\n+ /// assert_eq(5, storage.vec.get(0).unwrap().read());\\n+ /// assert_eq(10, storage.vec.get(1).unwrap().read());\\n+ /// assert_eq(20, storage.vec.get(2).unwrap().read());\\n+ /// assert_eq(20, storage.vec.get(3).unwrap().read());\\n ///\\n /// storage.vec.resize(2, 0);\\n ///\\n- /// assert(5 == storage.vec.get(0).unwrap().read());\\n- /// assert(10 == storage.vec.get(1).unwrap().read());\\n- /// assert(None == storage.vec.get(2));\\n- /// assert(None == storage.vec.get(3));\\n+ /// assert_eq(5, storage.vec.get(0).unwrap().read());\\n+ /// assert_eq(10, storage.vec.get(1).unwrap().read());\\n+ /// assert_eq(None, storage.vec.get(2));\\n+ /// assert_eq(None, storage.vec.get(3));\\n /// }\\n /// ```\\n #[storage(read, write)]\\n@@ -774,33 +909,25 @@ impl<V> StorageKey<StorageVec<V>> {\\n write_quads::<u64>(self.field_id(), 0, new_len);\\n }\\n \\n- // TODO: This should be moved into the vec.sw file and `From<StorageKey<StorageVec>> for Vec`\\n- // implemented instead of this when https://github.com/FuelLabs/sway/issues/409 is resolved.\\n- // Implementation will change from this:\\n- // ```sway\\n- // let my_vec = Vec::new();\\n- // storage.storage_vec.store_vec(my_vec);\\n- // let other_vec = storage.storage_vec.load_vec();\\n- // ```\\n- // To this:\\n- // ```sway\\n- // let my_vec = Vec::new();\\n- // storage.storage_vec = my_vec.into();\\n- // let other_vec = Vec::from(storage.storage_vec);\\n- // ```\\n- /// Stores a `Vec` as a `StorageVec`.\\n+ /// Stores given `vec` as a `StorageVec`.\\n ///\\n /// # Additional Information\\n ///\\n /// This will overwrite any existing values in the `StorageVec`.\\n ///\\n+ /// **This method is not supported for nested storage types and will revert if `V` is a nested storage type.**\\n+ ///\\n /// # Arguments\\n ///\\n /// * `vec`: [Vec<V>] - The vector to store in storage.\\n ///\\n+ /// # Reverts\\n+ ///\\n+ /// * If `V` is a nested storage type, i.e. if it is a zero-sized type.\\n+ ///\\n /// # Number of Storage Accesses\\n ///\\n- /// * Writes - `2`\\n+ /// * Writes: `2`\\n ///\\n /// # Examples\\n ///\\n@@ -817,32 +944,33 @@ impl<V> StorageKey<StorageVec<V>> {\\n ///\\n /// storage.vec.store_vec(vec);\\n ///\\n- /// assert(5 == storage.vec.get(0).unwrap().read());\\n- /// assert(10 == storage.vec.get(1).unwrap().read());\\n- /// assert(15 == storage.vec.get(2).unwrap().read());\\n+ /// assert_eq(5, storage.vec.get(0).unwrap().read());\\n+ /// assert_eq(10, storage.vec.get(1).unwrap().read());\\n+ /// assert_eq(15, storage.vec.get(2).unwrap().read());\\n /// }\\n /// ```\\n #[storage(write)]\\n pub fn store_vec(self, vec: Vec<V>) {\\n+ assert(__size_of::<V>() > 0);\\n+\\n let size_V_bytes = __size_of::<V>();\\n \\n- // Handle cases where elements are less than the size of word and pad to the size of a word\\n- let slice = if size_V_bytes < 8 {\\n+ // Handle cases where elements are not aligned to word boundaries and pad them.\\n+ let slice = if size_V_bytes % 8 != 0 {\\n let vec_slice = vec.as_raw_slice();\\n- let number_of_words = 8 * vec.len();\\n- let ptr = alloc_bytes(number_of_words);\\n+ let size_V_bytes_padded = ((size_V_bytes + 7) / 8) * 8;\\n+ let number_of_bytes = size_V_bytes_padded * vec.len();\\n+ let ptr = alloc_bytes(number_of_bytes);\\n let mut i = 0;\\n while i < vec.len() {\\n- // Insert into raw slice as offsets of 1 word per element\\n- // (size_of_word * element)\\n vec_slice\\n .ptr()\\n .add::<V>(i)\\n- .copy_bytes_to(ptr.add_uint_offset(8 * i), size_V_bytes);\\n+ .copy_bytes_to(ptr.add_uint_offset(size_V_bytes_padded * i), size_V_bytes);\\n i += 1;\\n }\\n \\n- raw_slice::from_parts::<V>(ptr, number_of_words)\\n+ raw_slice::from_parts::<u8>(ptr, number_of_bytes)\\n } else {\\n vec.as_raw_slice()\\n };\\n@@ -864,23 +992,23 @@ impl<V> StorageKey<StorageVec<V>> {\\n write_quads::<u64>(self.field_id(), 0, vec.len());\\n }\\n \\n- /// Load a `Vec` from the `StorageVec`.\\n+ /// Returns all elements contained in `self` as a `Vec<V>`.\\n ///\\n /// # Additional Information\\n ///\\n- /// This method does not work for any `V` type that has a 0 size, such as `StorageVec` itself. Meaning you cannot use this method on a `StorageVec<StorageVec<T>>`.\\n+ /// **This method is not supported for nested storage types and will revert if `V` is a nested storage type.**\\n ///\\n /// # Returns\\n ///\\n- /// * [Option<Vec<V>>] - The vector constructed from storage or `None`.\\n+ /// * [Vec<V>] - The vector containing all elements of `self`.\\n ///\\n /// # Reverts\\n ///\\n- /// * If the size of type `V` is 0.\\n+ /// * If `V` is a nested storage type, i.e. if it is a zero-sized type.\\n ///\\n /// # Number of Storage Accesses\\n ///\\n- /// * Reads - `2`\\n+ /// * Reads: `2`\\n ///\\n /// # Examples\\n ///\\n@@ -896,15 +1024,18 @@ impl<V> StorageKey<StorageVec<V>> {\\n /// vec.push(15);\\n ///\\n /// storage.vec.store_vec(vec);\\n- /// let returned_vec = storage.vec.load_vec();\\n ///\\n- /// assert(5 == returned_vec.get(0).unwrap());\\n- /// assert(10 == returned_vec.get(1).unwrap());\\n- /// assert(15 == returned_vec.get(2).unwrap());\\n+ /// let loaded_vec = storage.vec.load_vec();\\n+ ///\\n+ /// assert_eq(5, loaded_vec.get(0).unwrap());\\n+ /// assert_eq(10, loaded_vec.get(1).unwrap());\\n+ /// assert_eq(15, loaded_vec.get(2).unwrap());\\n /// }\\n /// ```\\n #[storage(read)]\\n pub fn load_vec(self) -> Vec<V> {\\n+ assert(__size_of::<V>() > 0);\\n+\\n // Get the length of the slice that is stored.\\n match read_quads::<u64>(self.field_id(), 0).unwrap_or(0) {\\n 0 => Vec::new(),\\n@@ -912,29 +1043,25 @@ impl<V> StorageKey<StorageVec<V>> {\\n // Get the number of storage slots needed based on the size.\\n let size_V_bytes = __size_of::<V>();\\n \\n- assert(size_V_bytes != 0);\\n-\\n- let bytes = if size_V_bytes < 8 {\\n- // Len * size_of_word\\n- len * 8\\n+ let bytes = if size_V_bytes % 8 != 0 {\\n+ let size_V_bytes_padded = ((size_V_bytes + 7) / 8) * 8;\\n+ len * size_V_bytes_padded\\n } else {\\n len * size_V_bytes\\n };\\n \\n let number_of_slots = (bytes + 31) >> 5;\\n let ptr = alloc_bytes(number_of_slots * 32);\\n- // Load the stored slice into the pointer.\\n let _ = __state_load_quad(sha256(self.field_id()), ptr, number_of_slots);\\n \\n- if size_V_bytes < 8 {\\n+ if size_V_bytes % 8 != 0 {\\n let len_bytes = len * size_V_bytes;\\n+ let size_V_bytes_padded = ((size_V_bytes + 7) / 8) * 8;\\n let new_vec = alloc_bytes(len_bytes);\\n let mut i = 0;\\n while i < len {\\n- // The stored vec is offset with 1 word per element, remove the padding for elements less than the size of a word\\n- // (size_of_word * element)\\n ptr\\n- .add_uint_offset((8 * i))\\n+ .add_uint_offset((size_V_bytes_padded * i))\\n .copy_bytes_to(new_vec.add::<V>(i), size_V_bytes);\\n i += 1;\\n }\\n@@ -959,7 +1086,11 @@ impl<V> StorageKey<StorageVec<V>> {\\n ///\\n /// # Returns\\n ///\\n- /// * [StorageVecIter<V>] - The struct which can be iterated over.\\n+ /// * [StorageVecIter<V>] - The iterator over this `StorageVec`.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// * Reads: `1` (to get the vector's length)\\n ///\\n /// # Examples\\n ///\\n@@ -973,13 +1104,14 @@ impl<V> StorageKey<StorageVec<V>> {\\n /// storage.vec.push(10);\\n /// storage.vec.push(15);\\n ///\\n- /// // Get the iterator\\n /// let iter = storage.vec.iter();\\n ///\\n /// assert_eq(5, iter.next().unwrap().read());\\n /// assert_eq(10, iter.next().unwrap().read());\\n /// assert_eq(15, iter.next().unwrap().read());\\n ///\\n+ /// let iter = storage.vec.iter();\\n+ ///\\n /// for elem in storage.vec.iter() {\\n /// let elem_value = elem.read();\\n /// log(elem_value);\\n@@ -996,7 +1128,6 @@ impl<V> StorageKey<StorageVec<V>> {\\n }\\n }\\n \\n-#[cfg(experimental_dynamic_storage = false)]\\n pub struct StorageVecIter<V> {\\n values: StorageKey<StorageVec<V>>,\\n len: u64,\\n@@ -1008,7 +1139,7 @@ impl<V> Iterator for StorageVecIter<V> {\\n type Item = StorageKey<V>;\\n fn next(ref mut self) -> Option<Self::Item> {\\n if self.index >= self.len {\\n- return None\\n+ return None;\\n }\\n \\n let key = sha256(self.values.field_id());\\n@@ -1021,10 +1152,1366 @@ impl<V> Iterator for StorageVecIter<V> {\\n }\\n }\\n \\n-// Add padding to type so it can correctly use the storage api\\n+/// Calculates the offset of the element at `index`\\n+/// starting from the beginning of the slot at which\\n+/// the `StorageVec` content starts.\\n+///\\n+/// Adds padding to the type size, so it can correctly\\n+/// use the storage api.\\n #[cfg(experimental_dynamic_storage = false)]\\n-fn offset_calculator<T>(offset: u64) -> u64 {\\n+fn offset_calculator<T>(index: u64) -> u64 {\\n let size_in_bytes = __size_of::<T>();\\n let size_in_bytes = (size_in_bytes + (8 - 1)) - ((size_in_bytes + (8 - 1)) % 8);\\n- (offset * size_in_bytes) / 8\\n+ (index * size_in_bytes) / 8\\n+}\\n+\\n+// A dynamic-slot-based `StorageVec` has two distinctive modes\\n+// of operations and storage access:\\n+//\\n+// 1. Storing non-zero-sized types\\n+// E.g., `StorageVec<u64>`. In this mode, the whole content\\n+// of the storage vec is stored in a single dynamic slot at `self.field_id`\\n+// and all the `StorageVec` methods are fully supported.\\n+//\\n+// 2. Storing nested storage types (zero-sized types)\\n+// E.g., `StorageVec<StorageVec<u64>>`. In this mode, the `self.field_id`\\n+// stores the vector's length, while the nested storage type at `index`\\n+// is stored at the slot calculated by `sha256((index, self.field_id))`.\\n+// In this mode, some `StorageVec` methods are not supported at all,\\n+// or have limitations or exceptional behaviors.\\n+//\\n+// Because of these two distinctive modes and the fact that implementation of\\n+// one of them gets optimized away (which we do want!), some of the methods have\\n+// different storage access patterns, in terms of reading and writing,\\n+// depending on `V` being a storage type or not.\\n+//\\n+// E.g., `push` requires a read and a write when `V` is a nested storage type,\\n+// and otherwise only a `write`. If we choose `#[storage(read, write)]` as the\\n+// purity attribute, we will get a warning that `read` is not needed, if `push`\\n+// is called for non-storage types.\\n+//\\n+// This is because the purity warnings are generated at the end of the compilation\\n+// pipeline.\\n+//\\n+// Currently, the only way to avoid purity warnings when `V` is a nested storage type\\n+// is the following:\\n+// - we omit `read` in `#[storage]` attributes and leave only `write`. The purity\\n+// attributes will reflect only the \\\"When `V` is a Nested Storage Type\\\" part of\\n+// the method doc-comment.\\n+// - for methods that are not supported at all for nested types, like, e.g. `set`,\\n+// we add a dummy `let _ = __state_clear(b256::zero(), 0);` call to simulate `write`\\n+// access. This is a workaround, but currently we don't have better options.\\n+// The real issue here is the problematic duality of the original `StorageVec` API,\\n+// which currently cannot be expressed via type system and trait constraints.\\n+#[cfg(experimental_dynamic_storage = true)]\\n+impl<V> StorageKey<StorageVec<V>> {\\n+ // TODO: We should have only one `STORES_STORAGE_TYPE` constant\\n+ // declared here as an associated constant. This is currently not possible\\n+ // because of these two limitations:\\n+ // 1. Having the below `const` uncommented causes compiler panic:\\n+ // https://github.com/FuelLabs/sway/issues/7615\\n+ // 2. All `StorageKey<StorageVec<V>>` types will actually share the same\\n+ // constant value because they have the same path, and are identified\\n+ // in IR only by path. **This is a known limitation that can lead to\\n+ // invalid compilation if 1. is solved before.**\\n+ // **We can use the below constant only when both above issues are solved.**\\n+ // Until then, we will have a local `STORES_STORAGE_TYPE` constant in\\n+ // every method that needs it.\\n+\\n+ // /// True if the `StorageVec` stores a storage type, i.e., if `V` is a storage type.\\n+ // const STORES_STORAGE_TYPE: bool = __size_of::<V>() == 0;\\n+\\n+ /// Appends `value` to the end of the vector.\\n+ ///\\n+ /// # Arguments\\n+ ///\\n+ /// * `value`: [V] - The item being added to the end of the vector.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// ## When `V` is a Non-storage Type\\n+ ///\\n+ /// * Internal preloads: `1` (to preload current content)\\n+ /// * Writes: `1` (to append the `value`)\\n+ ///\\n+ /// ## When `V` is a Nested Storage Type\\n+ ///\\n+ /// * Reads: `1` (to get the vector's length)\\n+ /// * Writes: `1` (to write the new, increased, vector's length)\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// use std::storage::storage_vec::*;\\n+ ///\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {},\\n+ /// vec_of_vec: StorageVec<StorageVec<u64>> = StorageVec {},\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// let five = 5_u64;\\n+ /// storage.vec.push(five);\\n+ /// assert_eq(five, storage.vec.get(0).unwrap().read());\\n+ ///\\n+ /// storage.vec_of_vec.push(StorageVec {});\\n+ /// assert_eq(0, storage.vec_of_vec.get(0).unwrap().len());\\n+ /// }\\n+ /// ```\\n+ #[storage(write)]\\n+ pub fn push(self, value: V) {\\n+ const STORES_STORAGE_TYPE: bool = __size_of::<V>() == 0;\\n+\\n+ if STORES_STORAGE_TYPE {\\n+ // Nothing to actually store. We just need to increment\\n+ // the vector's length. It is `get` that will return the\\n+ // proper `StorageKey` for the nested storage type `V`.\\n+ let len = read_slot::<u64>(self.field_id(), 0).unwrap_or(0);\\n+ write_slot(self.field_id(), len + 1);\\n+ } else {\\n+ append_slot(self.field_id(), value);\\n+ }\\n+ }\\n+\\n+ /// Removes the last element of the vector and returns it, or `None` if the vector is empty,\\n+ /// or it contains a nested storage type.\\n+ ///\\n+ /// # Additional Information\\n+ ///\\n+ /// **If `V` is a nested storage type, `pop` always returns `None`, even if the vector is not\\n+ /// empty and the last element got removed.**\\n+ ///\\n+ /// > **_WARNING:_** **If `V` is a nested storage type, `pop` will reduce the vector length and\\n+ /// remove the last element _from the vector_, but the content of the nested storage type\\n+ /// will remain in the storage.\\n+ ///\\n+ /// # Returns\\n+ ///\\n+ /// * [Option<V>] - The last element of the vector, or `None` if the vector is empty, or it contains a nested storage type.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// ## When `V` is a Non-storage Type\\n+ ///\\n+ /// * Preloads: `1` (to get the vector's length)\\n+ /// * Reads: `1` (to read the current content)\\n+ /// * Writes: `1` (to write the truncated content)\\n+ ///\\n+ /// ## When `V` is a Nested Storage Type\\n+ ///\\n+ /// * Reads: `1` (to get the vector's length)\\n+ /// * Writes: `1` (to write the new, decreased, vector's length)\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// use std::storage::storage_vec::*;\\n+ ///\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {},\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// let five = 5_u64;\\n+ /// storage.vec.push(five);\\n+ /// let popped_value = storage.vec.pop().unwrap();\\n+ /// assert_eq(five, popped_value);\\n+ /// let none_value = storage.vec.pop();\\n+ /// assert(none_value.is_none());\\n+ /// }\\n+ /// ```\\n+ #[storage(read, write)]\\n+ pub fn pop(self) -> Option<V> {\\n+ let len = self.len();\\n+\\n+ if len == 0 {\\n+ return None;\\n+ }\\n+\\n+ const STORES_STORAGE_TYPE: bool = __size_of::<V>() == 0;\\n+\\n+ if STORES_STORAGE_TYPE {\\n+ // Reducing len by 1, effectively removing the last item.\\n+ // Note that the value stored in the nested storage type\\n+ // **does not get removed from storage**.\\n+ write_slot(self.field_id(), len - 1);\\n+ None\\n+ } else {\\n+ const SIZE_OF_V: u64 = __size_of::<V>();\\n+\\n+ let len_in_bytes = len * SIZE_OF_V;\\n+ let new_len_in_bytes = len_in_bytes - SIZE_OF_V;\\n+\\n+ // 1. Get the current slot content.\\n+ let content_ptr = alloc_bytes(len_in_bytes);\\n+ let _ = __state_load_slot(self.field_id(), content_ptr, 0, len_in_bytes);\\n+\\n+ // 2. Truncate the slot content.\\n+ // Not that if the `new_len_in_bytes` is zero, the slot will still\\n+ // remain occupied but with an empty content. This fits the semantic\\n+ // of the empty `StorageVec` so there is no need for an additional\\n+ // check for zero and clearing the slot as a special case.\\n+ __state_store_slot(self.field_id(), content_ptr, new_len_in_bytes);\\n+\\n+ // 3. Return the last element.\\n+ Some(content_ptr.add::<u8>(new_len_in_bytes).read::<V>())\\n+ }\\n+ }\\n+\\n+ /// Gets the value at the given `index` or `None` if `index` is out of bounds.\\n+ ///\\n+ /// # Arguments\\n+ ///\\n+ /// * `index`: [u64] - The index to retrieve the item from.\\n+ ///\\n+ /// # Returns\\n+ ///\\n+ /// * [Option<StorageKey<V>>] - Location in storage of the value stored at `index` or `None` if `index` is out of bounds.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// ## When `V` is a Non-storage Type\\n+ ///\\n+ /// * Preloads: `1` (to get the vector's length)\\n+ ///\\n+ /// ## When `V` is a Nested Storage Type\\n+ ///\\n+ /// * Reads: `1` (to get the vector's length)\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// use std::storage::storage_vec::*;\\n+ ///\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {}\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// let five = 5_u64;\\n+ /// storage.vec.push(five);\\n+ /// assert_eq(five, storage.vec.get(0).unwrap().read());\\n+ /// assert(storage.vec.get(1).is_none());\\n+ /// }\\n+ /// ```\\n+ #[storage(read)]\\n+ pub fn get(self, index: u64) -> Option<StorageKey<V>> {\\n+ let len = self.len();\\n+\\n+ if len <= index {\\n+ return None;\\n+ }\\n+\\n+ const STORES_STORAGE_TYPE: bool = __size_of::<V>() == 0;\\n+\\n+ let (offset, field_id) = if STORES_STORAGE_TYPE {\\n+ // For nested storage types, we want to use a unique `field_id`\\n+ // set to `sha256((index, self.field_id())` to ensure every\\n+ // nested storage type element will use it and store its content\\n+ // in a different slot.\\n+ (0, sha256((index, self.field_id())))\\n+ } else {\\n+ // For non-zero-sized types, we know that their values are\\n+ // stored in the `self.field_id()` slot.\\n+ (index * __size_of::<V>(), self.field_id())\\n+ };\\n+\\n+ Some(StorageKey::<V>::new(self.field_id(), offset, field_id))\\n+ }\\n+\\n+ /// Removes the element at the given `index` and moves all the elements at the following indices\\n+ /// down one index. Returns the removed element.\\n+ ///\\n+ /// # Additional Information\\n+ ///\\n+ /// **This method is not supported for nested storage types and will panic if `V` is a nested storage type.**\\n+ ///\\n+ /// # Arguments\\n+ ///\\n+ /// * `index`: [u64] - The index to remove the element from.\\n+ ///\\n+ /// # Returns\\n+ ///\\n+ /// * [V] - The removed element.\\n+ ///\\n+ /// # Panics\\n+ ///\\n+ /// * `StorageVecError::IndexOutOfBounds`, if `index` is out of bounds.\\n+ /// * `StorageVecError::MethodDoesNotSupportNestedStorageTypes`, if `V` is a nested storage type, i.e. if it is a zero-sized type.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// * Preloads: `1` (to get vector's length)\\n+ /// * Loads: `1` (to read current slot content)\\n+ /// * Writes: `1` (to write truncated content)\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// use std::storage::storage_vec::*;\\n+ ///\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {}\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// storage.vec.push(5);\\n+ /// storage.vec.push(10);\\n+ /// storage.vec.push(15);\\n+ /// let removed_value = storage.vec.remove(1);\\n+ /// assert(10 == removed_value);\\n+ /// assert(storage.vec.len() == 2);\\n+ /// }\\n+ /// ```\\n+ #[storage(write)]\\n+ pub fn remove(self, index: u64) -> V {\\n+ const STORES_STORAGE_TYPE: bool = __size_of::<V>() == 0;\\n+\\n+ if STORES_STORAGE_TYPE {\\n+ // This workaround for satisfying the `#[storage]` attribute\\n+ // is explained in the comment above this `StorageVec` impl.\\n+ let _ = __state_clear(b256::zero(), 0);\\n+ panic StorageVecError::MethodDoesNotSupportNestedStorageTypes;\\n+ } else {\\n+ const SIZE_OF_V: u64 = __size_of::<V>();\\n+\\n+ let len = __state_preload(self.field_id()) / SIZE_OF_V;\\n+\\n+ if index >= len {\\n+ panic StorageVecError::IndexOutOfBounds(OutOfBounds {\\n+ length: len,\\n+ index,\\n+ });\\n+ }\\n+\\n+ let len_in_bytes = len * SIZE_OF_V;\\n+ let index_offset = index * SIZE_OF_V;\\n+ let new_len_in_bytes = len_in_bytes - SIZE_OF_V;\\n+\\n+ // 1. Read current slot content.\\n+ let content_ptr = alloc_bytes(len_in_bytes);\\n+ let _ = __state_load_slot(self.field_id(), content_ptr, 0, len_in_bytes);\\n+\\n+ // 2. Read the element to be removed before overriding the content.\\n+ let removed_element = content_ptr.add::<u8>(index_offset).read::<V>();\\n+\\n+ // 3. Shift everything after `index` one element to the left.\\n+ let content_after_removed_len = len_in_bytes - index_offset - SIZE_OF_V;\\n+ if content_after_removed_len > 0 {\\n+ // We first have to copy the trailing content to a new location,\\n+ // because memory copying requires non-overlapping memory locations.\\n+ let content_after_removed_ptr = alloc_bytes(content_after_removed_len);\\n+ content_ptr\\n+ .add::<u8>(index_offset + SIZE_OF_V)\\n+ .copy_bytes_to(content_after_removed_ptr, content_after_removed_len);\\n+\\n+ // Finally, copy the copy of the trailing content back into the original content.\\n+ content_after_removed_ptr.copy_bytes_to(\\n+ content_ptr\\n+ .add::<u8>(index_offset),\\n+ content_after_removed_len,\\n+ );\\n+ }\\n+\\n+ // 4. Write new content without the removed element to storage.\\n+ __state_store_slot(self.field_id(), content_ptr, new_len_in_bytes);\\n+\\n+ removed_element\\n+ }\\n+ }\\n+\\n+ /// Replaces the element at the given `index` with the last element, and removes the last element.\\n+ /// Returns the replaced element.\\n+ ///\\n+ /// # Additional Information\\n+ ///\\n+ /// **This method is not supported for nested storage types and will panic if `V` is a nested storage type.**\\n+ ///\\n+ /// If `index` is the index of the last element, the last element will be returned and removed from the vector.\\n+ ///\\n+ /// # Arguments\\n+ ///\\n+ /// * `index`: [u64] - The index at which to replace the element with the last element.\\n+ ///\\n+ /// # Returns\\n+ ///\\n+ /// * [V] - The replaced element.\\n+ ///\\n+ /// # Panics\\n+ ///\\n+ /// * `StorageVecError::IndexOutOfBounds`, if `index` is out of bounds.\\n+ /// * `StorageVecError::MethodDoesNotSupportNestedStorageTypes`, if `V` is a nested storage type, i.e. if it is a zero-sized type.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// * Preloads: `1` (to get vector's length)\\n+ /// * Loads: `1` (to read current slot content)\\n+ /// * Writes: `1` (to write content with the last element placed at `index`, truncated by one element)\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// use std::storage::storage_vec::*;\\n+ ///\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {}\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// storage.vec.push(5);\\n+ /// storage.vec.push(10);\\n+ /// storage.vec.push(15);\\n+ /// let removed_value = storage.vec.swap_remove(0);\\n+ /// assert_eq(5, removed_value);\\n+ /// let swapped_value = storage.vec.get(0).unwrap().read();\\n+ /// assert_eq(15, swapped_value); // The first element is replaced by the last element.\\n+ /// assert_eq(2, storage.vec.len()); // The last element is removed.\\n+ /// }\\n+ /// ```\\n+ #[storage(write)]\\n+ pub fn swap_remove(self, index: u64) -> V {\\n+ const STORES_STORAGE_TYPE: bool = __size_of::<V>() == 0;\\n+\\n+ if STORES_STORAGE_TYPE {\\n+ // This workaround for satisfying the `#[storage]` attribute\\n+ // is explained in the comment above this `StorageVec` impl.\\n+ let _ = __state_clear(b256::zero(), 0);\\n+ panic StorageVecError::MethodDoesNotSupportNestedStorageTypes;\\n+ } else {\\n+ const SIZE_OF_V: u64 = __size_of::<V>();\\n+\\n+ let len = __state_preload(self.field_id()) / SIZE_OF_V;\\n+\\n+ if index >= len {\\n+ panic StorageVecError::IndexOutOfBounds(OutOfBounds {\\n+ length: len,\\n+ index,\\n+ });\\n+ }\\n+\\n+ let len_in_bytes = len * SIZE_OF_V;\\n+ let index_offset = index * SIZE_OF_V;\\n+ let new_len_in_bytes = len_in_bytes - SIZE_OF_V;\\n+\\n+ // 1. Read current slot content.\\n+ let content_ptr = alloc_bytes(len_in_bytes);\\n+ let _ = __state_load_slot(self.field_id(), content_ptr, 0, len_in_bytes);\\n+\\n+ // 2. Read the element to be replaced/removed before overriding the content.\\n+ let removed_element = content_ptr.add::<u8>(index_offset).read::<V>();\\n+\\n+ // 3. Overwrite element at `index` with the last element (only if `index` is not already the last).\\n+ if index != len - 1 {\\n+ let last_element_ptr = content_ptr.add::<u8>(new_len_in_bytes);\\n+ last_element_ptr.copy_bytes_to(content_ptr.add::<u8>(index_offset), SIZE_OF_V);\\n+ }\\n+\\n+ // 4. Write new content without the last element to storage.\\n+ __state_store_slot(self.field_id(), content_ptr, new_len_in_bytes);\\n+\\n+ removed_element\\n+ }\\n+ }\\n+\\n+ /// Sets the `value` at the given `index`.\\n+ ///\\n+ /// # Additional Information\\n+ ///\\n+ /// **This method is not supported for nested storage types and will panic if `V` is a nested storage type.**\\n+ ///\\n+ /// # Arguments\\n+ ///\\n+ /// * `index`: [u64] - The index to set the value at.\\n+ /// * `value`: [V] - The value to be set.\\n+ ///\\n+ /// # Panics\\n+ ///\\n+ /// * `StorageVecError::IndexOutOfBounds`, if `index` is out of bounds.\\n+ /// * `StorageVecError::MethodDoesNotSupportNestedStorageTypes`, if `V` is a nested storage type, i.e. if it is a zero-sized type.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// * Preloads: `1` (to get the vector's length)\\n+ /// * Writes: `1`\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// use std::storage::storage_vec::*;\\n+ ///\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {}\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// storage.vec.push(5);\\n+ /// storage.vec.push(10);\\n+ ///\\n+ /// storage.vec.set(0, 15);\\n+ /// let set_value = storage.vec.get(0).unwrap().read();\\n+ /// assert_eq(15, set_value);\\n+ /// }\\n+ /// ```\\n+ #[storage(write)]\\n+ pub fn set(self, index: u64, value: V) {\\n+ const STORES_STORAGE_TYPE: bool = __size_of::<V>() == 0;\\n+\\n+ if STORES_STORAGE_TYPE {\\n+ // This workaround for satisfying the `#[storage]` attribute\\n+ // is explained in the comment above this `StorageVec` impl.\\n+ let _ = __state_clear(b256::zero(), 0);\\n+ panic StorageVecError::MethodDoesNotSupportNestedStorageTypes;\\n+ } else {\\n+ const SIZE_OF_V: u64 = __size_of::<V>();\\n+\\n+ let len = __state_preload(self.field_id()) / SIZE_OF_V;\\n+ if index >= len {\\n+ panic StorageVecError::IndexOutOfBounds(OutOfBounds {\\n+ length: len,\\n+ index,\\n+ });\\n+ }\\n+\\n+ __state_update_slot(\\n+ self\\n+ .field_id(),\\n+ __addr_of::<V>(value),\\n+ index * SIZE_OF_V,\\n+ SIZE_OF_V,\\n+ );\\n+ }\\n+ }\\n+\\n+ /// Inserts the `value` at the given `index`, moving the current value at `index`\\n+ /// as well as the following indices up by one index.\\n+ ///\\n+ /// # Additional Information\\n+ ///\\n+ /// **This method is not supported for nested storage types and will panic if `V` is a nested storage type.**\\n+ ///\\n+ /// If `index` is equal to vector's length, appends the `value` at the end of the\\n+ /// vector, effectively acting the same as `push`.\\n+ ///\\n+ /// # Arguments\\n+ ///\\n+ /// * `index`: [u64] - The index to insert the value into.\\n+ /// * `value`: [V] - The value to insert.\\n+ ///\\n+ /// # Panics\\n+ ///\\n+ /// * `StorageVecError::IndexOutOfBounds`, if `index` is larger than the length of the vector.\\n+ /// * `StorageVecError::MethodDoesNotSupportNestedStorageTypes`, if `V` is a nested storage type, i.e. if it is a zero-sized type.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// * Preloads: `1` (to get vector's length)\\n+ /// * Loads: `0` in case of an append at the end, or `1` if inserting\\n+ /// * Writes: `1` in case of an append at the end, or `2` if inserting\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// use std::storage::storage_vec::*;\\n+ ///\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {}\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// storage.vec.push(5);\\n+ /// storage.vec.push(15);\\n+ ///\\n+ /// storage.vec.insert(1, 10);\\n+ ///\\n+ /// assert_eq(5, storage.vec.get(0).unwrap().read());\\n+ /// assert_eq(10, storage.vec.get(1).unwrap().read());\\n+ /// assert_eq(15, storage.vec.get(2).unwrap().read());\\n+ /// }\\n+ /// ```\\n+ #[storage(write)]\\n+ pub fn insert(self, index: u64, value: V) {\\n+ const STORES_STORAGE_TYPE: bool = __size_of::<V>() == 0;\\n+\\n+ if STORES_STORAGE_TYPE {\\n+ // This workaround for satisfying the `#[storage]` attribute\\n+ // is explained in the comment above this `StorageVec` impl.\\n+ let _ = __state_clear(b256::zero(), 0);\\n+ panic StorageVecError::MethodDoesNotSupportNestedStorageTypes;\\n+ } else {\\n+ const SIZE_OF_V: u64 = __size_of::<V>();\\n+\\n+ let len = __state_preload(self.field_id()) / SIZE_OF_V;\\n+ if index > len {\\n+ panic StorageVecError::IndexOutOfBounds(OutOfBounds {\\n+ length: len,\\n+ index,\\n+ });\\n+ }\\n+\\n+ if index == len {\\n+ append_slot(self.field_id(), value);\\n+ } else {\\n+ let len_in_bytes = len * SIZE_OF_V;\\n+ let index_offset = index * SIZE_OF_V;\\n+\\n+ // 1. Get the current slot content.\\n+ let content_ptr = alloc_bytes(len_in_bytes);\\n+ let _ = __state_load_slot(self.field_id(), content_ptr, 0, len_in_bytes);\\n+\\n+ // 2. Write the `value` at `index`.\\n+ __state_update_slot(\\n+ self\\n+ .field_id(),\\n+ __addr_of::<V>(value),\\n+ index_offset,\\n+ SIZE_OF_V,\\n+ );\\n+\\n+ // 3. Write the previous content that should come after the inserted `value`.\\n+ let content_after_index_ptr = content_ptr.add::<u8>(index_offset);\\n+ let content_after_index_len = len_in_bytes - index_offset;\\n+ __state_update_slot(\\n+ self\\n+ .field_id(),\\n+ content_after_index_ptr,\\n+ index_offset + SIZE_OF_V,\\n+ content_after_index_len,\\n+ );\\n+ }\\n+ }\\n+ }\\n+\\n+ /// Returns the length of the vector.\\n+ ///\\n+ /// # Returns\\n+ ///\\n+ /// * [u64] - The length of the vector.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// ## When `V` is a Non-storage Type\\n+ ///\\n+ /// * Preloads: `1` (to get the vector's length)\\n+ ///\\n+ /// ## When `V` is a Nested Storage Type\\n+ ///\\n+ /// * Reads: `1` (to get the vector's length)\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// use std::storage::storage_vec::*;\\n+ ///\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {},\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// assert_eq(0, storage.vec.len());\\n+ /// storage.vec.push(5);\\n+ /// assert_eq(1, storage.vec.len());\\n+ /// storage.vec.push(10);\\n+ /// assert_eq(2, storage.vec.len());\\n+ /// }\\n+ /// ```\\n+ #[storage(read)]\\n+ pub fn len(self) -> u64 {\\n+ const STORES_STORAGE_TYPE: bool = __size_of::<V>() == 0;\\n+\\n+ if STORES_STORAGE_TYPE {\\n+ read_slot::<u64>(self.field_id(), 0).unwrap_or(0)\\n+ } else {\\n+ __state_preload(self.field_id()) / __size_of::<V>()\\n+ }\\n+ }\\n+\\n+ /// Returns true if the vector is empty, otherwise false.\\n+ ///\\n+ /// # Returns\\n+ ///\\n+ /// * [bool] - Indicates whether the vector is empty or not.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// ## When `V` is a Non-storage Type\\n+ ///\\n+ /// * Preloads: `1` (to get the vector's length)\\n+ ///\\n+ /// ## When `V` is a Nested Storage Type\\n+ ///\\n+ /// * Reads: `1` (to get the vector's length)\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// use std::storage::storage_vec::*;\\n+ ///\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {}\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// assert(storage.vec.is_empty());\\n+ /// storage.vec.push(5);\\n+ /// assert(!storage.vec.is_empty());\\n+ /// storage.vec.clear();\\n+ /// assert(storage.vec.is_empty());\\n+ /// }\\n+ /// ```\\n+ #[storage(read)]\\n+ pub fn is_empty(self) -> bool {\\n+ self.len() == 0\\n+ }\\n+\\n+ /// Swaps the positions of the two elements at the given indices.\\n+ ///\\n+ /// # Additional Information\\n+ ///\\n+ /// **This method is not supported for nested storage types and will panic if `V` is a nested storage type.**\\n+ ///\\n+ /// If `element1_index` and `element2_index` are equal, this method does not read from or write into the storage,\\n+ /// aside from preloading the vectors length.\\n+ ///\\n+ /// # Arguments\\n+ ///\\n+ /// * `element1_index`: [u64] - The index of the first element.\\n+ /// * `element2_index`: [u64] - The index of the second element.\\n+ ///\\n+ /// # Panics\\n+ ///\\n+ /// * `StorageVecError::IndexOutOfBounds`, if `element1_index` or `element2_index` is out of bounds.\\n+ /// * `StorageVecError::MethodDoesNotSupportNestedStorageTypes`, if `V` is a nested storage type, i.e. if it is a zero-sized type.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// * Preloads: `1` (to get the vector's length)\\n+ /// * Loads: `1` (to read current slot content when the indices differ)\\n+ /// * Writes: `1` (to write the swapped content when the indices differ)\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// use std::storage::storage_vec::*;\\n+ ///\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {}\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// storage.vec.push(5);\\n+ /// storage.vec.push(10);\\n+ /// storage.vec.push(15);\\n+ ///\\n+ /// storage.vec.swap(0, 2);\\n+ /// assert_eq(15, storage.vec.get(0).unwrap().read());\\n+ /// assert_eq(10, storage.vec.get(1).unwrap().read());\\n+ /// assert_eq(5, storage.vec.get(2).unwrap().read());\\n+ /// }\\n+ /// ```\\n+ #[storage(write)]\\n+ pub fn swap(self, element1_index: u64, element2_index: u64) {\\n+ const STORES_STORAGE_TYPE: bool = __size_of::<V>() == 0;\\n+\\n+ if STORES_STORAGE_TYPE {\\n+ // This workaround for satisfying the `#[storage]` attribute\\n+ // is explained in the comment above this `StorageVec` impl.\\n+ let _ = __state_clear(b256::zero(), 0);\\n+ panic StorageVecError::MethodDoesNotSupportNestedStorageTypes;\\n+ } else {\\n+ const SIZE_OF_V: u64 = __size_of::<V>();\\n+\\n+ let len = __state_preload(self.field_id()) / SIZE_OF_V;\\n+\\n+ if element1_index >= len {\\n+ panic StorageVecError::IndexOutOfBounds(OutOfBounds {\\n+ length: len,\\n+ index: element1_index,\\n+ });\\n+ }\\n+\\n+ if element2_index >= len {\\n+ panic StorageVecError::IndexOutOfBounds(OutOfBounds {\\n+ length: len,\\n+ index: element2_index,\\n+ });\\n+ }\\n+\\n+ if element1_index == element2_index {\\n+ return;\\n+ }\\n+\\n+ let len_in_bytes = len * SIZE_OF_V;\\n+ let element1_offset = element1_index * SIZE_OF_V;\\n+ let element2_offset = element2_index * SIZE_OF_V;\\n+\\n+ let content_ptr = alloc_bytes(len_in_bytes);\\n+ let _ = __state_load_slot(self.field_id(), content_ptr, 0, len_in_bytes);\\n+\\n+ // Copy first element to a temporary.\\n+ let element1_value_ptr = alloc_bytes(SIZE_OF_V);\\n+ content_ptr\\n+ .add::<u8>(element1_offset)\\n+ .copy_bytes_to(element1_value_ptr, SIZE_OF_V);\\n+\\n+ content_ptr\\n+ .add::<u8>(element2_offset)\\n+ .copy_bytes_to(content_ptr.add::<u8>(element1_offset), SIZE_OF_V);\\n+ element1_value_ptr.copy_bytes_to(content_ptr.add::<u8>(element2_offset), SIZE_OF_V);\\n+\\n+ __state_store_slot(self.field_id(), content_ptr, len_in_bytes);\\n+ }\\n+ }\\n+\\n+ /// Returns the first element of the vector, or `None` if it is empty.\\n+ ///\\n+ /// # Returns\\n+ ///\\n+ /// * [Option<StorageKey<V>>] - The location in storage of the value stored at\\n+ /// the start of the vector, or `None` if the vector is empty.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// * Reads: `1` (to get vector's length)\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {},\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// assert(storage.vec.first().is_none());\\n+ /// storage.vec.push(5);\\n+ /// assert_eq(5, storage.vec.first().unwrap().read());\\n+ /// }\\n+ /// ```\\n+ #[storage(read)]\\n+ pub fn first(self) -> Option<StorageKey<V>> {\\n+ let len = self.len();\\n+\\n+ if len == 0 {\\n+ return None;\\n+ }\\n+\\n+ const STORES_STORAGE_TYPE: bool = __size_of::<V>() == 0;\\n+\\n+ let field_id = if STORES_STORAGE_TYPE {\\n+ // Nested storage types are stored at a unique `field_id`\\n+ // set to `sha256((<index>, self.field_id())` to ensure every\\n+ // nested storage type element will use it and store its content\\n+ // in a different slot.\\n+ sha256((0, self.field_id()))\\n+ } else {\\n+ // For non-zero-sized types, their values are\\n+ // stored in the `self.field_id()` slot.\\n+ self.field_id()\\n+ };\\n+\\n+ Some(StorageKey::<V>::new(self.field_id(), 0, field_id))\\n+ }\\n+\\n+ /// Returns the last element of the vector, or `None` if it is empty.\\n+ ///\\n+ /// # Returns\\n+ ///\\n+ /// * [Option<StorageKey<V>>] - The location in storage of the value stored at\\n+ /// the end of the vector, or `None` if the vector is empty.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// * Reads: `1` (to get vector's length)\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {},\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// assert(storage.vec.last().is_none());\\n+ /// storage.vec.push(5);\\n+ /// storage.vec.push(10);\\n+ /// assert_eq(10, storage.vec.last().unwrap().read());\\n+ /// }\\n+ /// ```\\n+ #[storage(read)]\\n+ pub fn last(self) -> Option<StorageKey<V>> {\\n+ let len = self.len();\\n+\\n+ if len == 0 {\\n+ return None;\\n+ }\\n+\\n+ const STORES_STORAGE_TYPE: bool = __size_of::<V>() == 0;\\n+\\n+ let (offset, field_id) = if STORES_STORAGE_TYPE {\\n+ // Nested storage types are stored at a unique `field_id`\\n+ // set to `sha256((<index>, self.field_id())` to ensure every\\n+ // nested storage type element will use it and store its content\\n+ // in a different slot.\\n+ (0, sha256((len - 1, self.field_id())))\\n+ } else {\\n+ // For non-zero-sized types, their values are\\n+ // stored in the `self.field_id()` slot.\\n+ ((len - 1) * __size_of::<V>(), self.field_id())\\n+ };\\n+\\n+ Some(StorageKey::<V>::new(self.field_id(), offset, field_id))\\n+ }\\n+\\n+ /// Reverses the order of elements in the vector, in place.\\n+ ///\\n+ /// # Additional Information\\n+ ///\\n+ /// **This method is not supported for nested storage types and will panic if `V` is a nested storage type.**\\n+ ///\\n+ /// # Panics\\n+ ///\\n+ /// * `StorageVecError::MethodDoesNotSupportNestedStorageTypes`, if `V` is a nested storage type, i.e. if it is a zero-sized type.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// * Preloads: `1` (to get vector's length)\\n+ /// * Loads: `1` when `self.len() >= 2`, otherwise `0`\\n+ /// * Writes: `1` when `self.len() >= 2`, otherwise `0`\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {},\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// storage.vec.push(5);\\n+ /// storage.vec.push(10);\\n+ /// storage.vec.push(15);\\n+ ///\\n+ /// storage.vec.reverse();\\n+ ///\\n+ /// assert_eq(15, storage.vec.get(0).unwrap().read());\\n+ /// assert_eq(10, storage.vec.get(1).unwrap().read());\\n+ /// assert_eq(5, storage.vec.get(2).unwrap().read());\\n+ /// }\\n+ /// ```\\n+ #[storage(write)]\\n+ pub fn reverse(self) {\\n+ const STORES_STORAGE_TYPE: bool = __size_of::<V>() == 0;\\n+\\n+ if STORES_STORAGE_TYPE {\\n+ // This workaround for satisfying the `#[storage]` attribute\\n+ // is explained in the comment above this `StorageVec` impl.\\n+ let _ = __state_clear(b256::zero(), 0);\\n+ panic StorageVecError::MethodDoesNotSupportNestedStorageTypes;\\n+ } else {\\n+ const SIZE_OF_V: u64 = __size_of::<V>();\\n+\\n+ let len = __state_preload(self.field_id()) / SIZE_OF_V;\\n+\\n+ if len < 2 {\\n+ return;\\n+ }\\n+\\n+ let len_in_bytes = len * SIZE_OF_V;\\n+ let content_ptr = alloc_bytes(len_in_bytes);\\n+ let _ = __state_load_slot(self.field_id(), content_ptr, 0, len_in_bytes);\\n+\\n+ // Allocate a temporary for swaps.\\n+ let tmp_ptr = alloc_bytes(SIZE_OF_V);\\n+\\n+ let mid = len / 2;\\n+ let mut i = 0;\\n+ while i < mid {\\n+ let left_offset = i * SIZE_OF_V;\\n+ let right_offset = (len - i - 1) * SIZE_OF_V;\\n+\\n+ // tmp <- left.\\n+ content_ptr.add::<u8>(left_offset).copy_bytes_to(tmp_ptr, SIZE_OF_V);\\n+\\n+ // right -> left.\\n+ content_ptr\\n+ .add::<u8>(right_offset)\\n+ .copy_bytes_to(content_ptr.add::<u8>(left_offset), SIZE_OF_V);\\n+\\n+ // tmp -> right.\\n+ tmp_ptr.copy_bytes_to(content_ptr.add::<u8>(right_offset), SIZE_OF_V);\\n+\\n+ i += 1;\\n+ }\\n+\\n+ __state_store_slot(self.field_id(), content_ptr, len_in_bytes);\\n+ }\\n+ }\\n+\\n+ /// Replaces all elements in the vector with `value`.\\n+ ///\\n+ /// # Additional Information\\n+ ///\\n+ /// **This method is not supported for nested storage types and will panic if `V` is a nested storage type.**\\n+ ///\\n+ /// # Arguments\\n+ ///\\n+ /// * `value`: [V] - Value to copy to each element of the vector.\\n+ ///\\n+ /// # Panics\\n+ ///\\n+ /// * `StorageVecError::MethodDoesNotSupportNestedStorageTypes`, if `V` is a nested storage type, i.e. if it is a zero-sized type.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// * Preloads: `1` (to get vector's length)\\n+ /// * Writes: `1` if `self.len() > 0`, otherwise `0`\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {},\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// storage.vec.push(5);\\n+ /// storage.vec.push(10);\\n+ /// storage.vec.push(15);\\n+\\n+ /// storage.vec.fill(20);\\n+ ///\\n+ /// assert_eq(20, storage.vec.get(0).unwrap().read());\\n+ /// assert_eq(20, storage.vec.get(1).unwrap().read());\\n+ /// assert_eq(20, storage.vec.get(2).unwrap().read());\\n+ /// }\\n+ /// ```\\n+ #[storage(write)]\\n+ pub fn fill(self, value: V) {\\n+ const STORES_STORAGE_TYPE: bool = __size_of::<V>() == 0;\\n+\\n+ if STORES_STORAGE_TYPE {\\n+ // This workaround for satisfying the `#[storage]` attribute\\n+ // is explained in the comment above this `StorageVec` impl.\\n+ let _ = __state_clear(b256::zero(), 0);\\n+ panic StorageVecError::MethodDoesNotSupportNestedStorageTypes;\\n+ } else {\\n+ const SIZE_OF_V: u64 = __size_of::<V>();\\n+\\n+ let len = __state_preload(self.field_id()) / SIZE_OF_V;\\n+\\n+ if len == 0 {\\n+ return;\\n+ }\\n+\\n+ let len_in_bytes = len * SIZE_OF_V;\\n+ let content_ptr = alloc_bytes(len_in_bytes);\\n+\\n+ let value_ptr = __addr_of::<V>(value);\\n+\\n+ let mut i = 0;\\n+ while i < len {\\n+ value_ptr.copy_bytes_to(content_ptr.add::<u8>(i * SIZE_OF_V), SIZE_OF_V);\\n+ i += 1;\\n+ }\\n+\\n+ __state_store_slot(self.field_id(), content_ptr, len_in_bytes);\\n+ }\\n+ }\\n+\\n+ /// Resizes `self` in place so that `len` is equal to `new_len`.\\n+ ///\\n+ /// # Additional Information\\n+ ///\\n+ /// If `new_len` is greater than `len`, `self` is extended by the difference, with each\\n+ /// additional element being set to `value`. If the `new_len` is less than `len`, `self` is\\n+ /// simply truncated.\\n+ ///\\n+ /// > **_WARNING:_** **If `V` is a nested storage type and `new_len` is less than `len`,\\n+ /// `resize` will reduce the vector length and remove the remaining elements _from the vector_,\\n+ /// but the nested content of those removed elements will remain in the storage.**\\n+ ///\\n+ /// # Arguments\\n+ ///\\n+ /// * `new_len`: [u64] - The new length to expand or truncate to.\\n+ /// * `value`: [V] - The value to set new elements to, if the `new_len` is greater than the current length.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// ## When `V` is a Non-storage Type\\n+ ///\\n+ /// * Preloads: `1` (to get vector's length)\\n+ /// * Loads: `1` when `new_len < len`, or when `new_len > len && len > 0`; otherwise `0`\\n+ /// * Writes: `1` when `new_len != len`; otherwise `0`\\n+ ///\\n+ /// ## When `V` is a Nested Storage Type\\n+ ///\\n+ /// * Writes: `1` (to write the new vector's length)\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {},\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// storage.vec.push(5);\\n+ /// storage.vec.push(10);\\n+ ///\\n+ /// storage.vec.resize(4, 20);\\n+ ///\\n+ /// assert_eq(5, storage.vec.get(0).unwrap().read());\\n+ /// assert_eq(10, storage.vec.get(1).unwrap().read());\\n+ /// assert_eq(20, storage.vec.get(2).unwrap().read());\\n+ /// assert_eq(20, storage.vec.get(3).unwrap().read());\\n+ ///\\n+ /// storage.vec.resize(2, 0);\\n+ ///\\n+ /// assert_eq(5, storage.vec.get(0).unwrap().read());\\n+ /// assert_eq(10, storage.vec.get(1).unwrap().read());\\n+ /// assert_eq(None, storage.vec.get(2));\\n+ /// assert_eq(None, storage.vec.get(3));\\n+ /// }\\n+ /// ```\\n+ #[storage(write)]\\n+ pub fn resize(self, new_len: u64, value: V) {\\n+ const STORES_STORAGE_TYPE: bool = __size_of::<V>() == 0;\\n+\\n+ if STORES_STORAGE_TYPE {\\n+ // For nested storage types, we only adjust the length.\\n+ // The eventual existing content of the nested storage types\\n+ // is not touched, matching the behavior of `push` and `pop`.\\n+ write_slot(self.field_id(), new_len);\\n+ } else {\\n+ const SIZE_OF_V: u64 = __size_of::<V>();\\n+\\n+ let len = __state_preload(self.field_id()) / SIZE_OF_V;\\n+\\n+ if new_len == len {\\n+ return;\\n+ }\\n+\\n+ let len_in_bytes = len * SIZE_OF_V;\\n+ let new_len_in_bytes = new_len * SIZE_OF_V;\\n+\\n+ let content_ptr = alloc_bytes(new_len_in_bytes);\\n+\\n+ if new_len < len {\\n+ // Truncation keeps the prefix and drops the tail.\\n+ // We need to load only the prefix part, `new_len_in_bytes`.\\n+ let _ = __state_load_slot(self.field_id(), content_ptr, 0, new_len_in_bytes);\\n+ } else {\\n+ // Growth keeps existing content and fills the tail in-memory before the write.\\n+ // We need to load all the existing content, `len_in_bytes`.\\n+ if len_in_bytes > 0 {\\n+ let _ = __state_load_slot(self.field_id(), content_ptr, 0, len_in_bytes);\\n+ }\\n+\\n+ let value_ptr = __addr_of::<V>(value);\\n+ let mut i = len;\\n+ while i < new_len {\\n+ value_ptr.copy_bytes_to(content_ptr.add::<u8>(i * SIZE_OF_V), SIZE_OF_V);\\n+ i += 1;\\n+ }\\n+ }\\n+\\n+ __state_store_slot(self.field_id(), content_ptr, new_len_in_bytes);\\n+ }\\n+ }\\n+\\n+ /// Stores given `vec` as a `StorageVec`.\\n+ ///\\n+ /// # Additional Information\\n+ ///\\n+ /// **This method is not supported for nested storage types and will panic if `V` is a nested storage type.**\\n+ ///\\n+ /// # Arguments\\n+ ///\\n+ /// * `vec`: [Vec<V>] - The vector to store in storage.\\n+ ///\\n+ /// # Panics\\n+ ///\\n+ /// * `StorageVecError::MethodDoesNotSupportNestedStorageTypes`, if `V` is a nested storage type, i.e. if it is a zero-sized type.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// * Writes: `1`\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {},\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// let mut heap_vec = Vec::<u64>::new();\\n+ /// heap_vec.push(5);\\n+ /// heap_vec.push(10);\\n+ /// heap_vec.push(15);\\n+ ///\\n+ /// storage.vec.store_vec(heap_vec);\\n+ ///\\n+ /// assert_eq(5, storage.vec.get(0).unwrap().read());\\n+ /// assert_eq(10, storage.vec.get(1).unwrap().read());\\n+ /// assert_eq(15, storage.vec.get(2).unwrap().read());\\n+ /// }\\n+ /// ```\\n+ #[storage(write)]\\n+ pub fn store_vec(self, vec: Vec<V>) {\\n+ const STORES_STORAGE_TYPE: bool = __size_of::<V>() == 0;\\n+\\n+ if STORES_STORAGE_TYPE {\\n+ // This workaround for satisfying the `#[storage]` attribute\\n+ // is explained in the comment above this `StorageVec` impl.\\n+ let _ = __state_clear(b256::zero(), 0);\\n+ panic StorageVecError::MethodDoesNotSupportNestedStorageTypes;\\n+ } else {\\n+ let (ptr, len) = vec.as_raw_slice().into_parts();\\n+ __state_store_slot(self.field_id(), ptr, len);\\n+ }\\n+ }\\n+\\n+ /// Returns all elements contained in `self` as a `Vec<V>`.\\n+ ///\\n+ /// # Additional Information\\n+ ///\\n+ /// **This method is not supported for nested storage types and will panic if `V` is a nested storage type.**\\n+ ///\\n+ /// # Returns\\n+ ///\\n+ /// * [Vec<V>] - The vector containing all elements of `self`.\\n+ ///\\n+ /// # Panics\\n+ ///\\n+ /// * `StorageVecError::MethodDoesNotSupportNestedStorageTypes`, if `V` is a nested storage type, i.e. if it is a zero-sized type.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// * Preloads: `1` (to get vector's length)\\n+ /// * Reads: `1`\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {},\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// let mut vec = Vec::<u64>::new();\\n+ /// vec.push(5);\\n+ /// vec.push(10);\\n+ /// vec.push(15);\\n+ ///\\n+ /// storage.vec.store_vec(vec);\\n+ ///\\n+ /// let loaded_vec = storage.vec.load_vec();\\n+ ///\\n+ /// assert_eq(5, loaded_vec.get(0).unwrap());\\n+ /// assert_eq(10, loaded_vec.get(1).unwrap());\\n+ /// assert_eq(15, loaded_vec.get(2).unwrap());\\n+ /// }\\n+ /// ```\\n+ #[storage(read)]\\n+ pub fn load_vec(self) -> Vec<V> {\\n+ const STORES_STORAGE_TYPE: bool = __size_of::<V>() == 0;\\n+\\n+ if STORES_STORAGE_TYPE {\\n+ // This workaround for satisfying the `#[storage]` attribute\\n+ // is explained in the comment above this `StorageVec` impl.\\n+ let _ = __state_preload(self.field_id());\\n+ panic StorageVecError::MethodDoesNotSupportNestedStorageTypes;\\n+ } else {\\n+ let len_in_bytes = __state_preload(self.field_id());\\n+ if len_in_bytes == 0 {\\n+ Vec::new()\\n+ } else {\\n+ let content_ptr = alloc_bytes(len_in_bytes);\\n+ let _ = __state_load_slot(self.field_id(), content_ptr, 0, len_in_bytes);\\n+ Vec::from(raw_slice::from_parts::<V>(content_ptr, len_in_bytes / __size_of::<V>()))\\n+ }\\n+ }\\n+ }\\n+\\n+ /// Returns an [Iterator] to iterate over this `StorageVec`.\\n+ ///\\n+ /// # Returns\\n+ ///\\n+ /// * [StorageVecIter<V>] - The iterator over this `StorageVec`.\\n+ ///\\n+ /// # Number of Storage Accesses\\n+ ///\\n+ /// ## When `V` is a Non-storage Type\\n+ ///\\n+ /// * Preloads: `1` (to get the vector's length)\\n+ ///\\n+ /// ## When `V` is a Nested Storage Type\\n+ ///\\n+ /// * Reads: `1` (to get the vector's length)\\n+ ///\\n+ /// # Examples\\n+ ///\\n+ /// ```sway\\n+ /// storage {\\n+ /// vec: StorageVec<u64> = StorageVec {},\\n+ /// }\\n+ ///\\n+ /// fn foo() {\\n+ /// storage.vec.push(5);\\n+ /// storage.vec.push(10);\\n+ /// storage.vec.push(15);\\n+ ///\\n+ /// let iter = storage.vec.iter();\\n+ ///\\n+ /// assert_eq(5, iter.next().unwrap().read());\\n+ /// assert_eq(10, iter.next().unwrap().read());\\n+ /// assert_eq(15, iter.next().unwrap().read());\\n+ ///\\n+ /// let iter = storage.vec.iter();\\n+ ///\\n+ /// for elem in storage.vec.iter() {\\n+ /// let elem_value = elem.read();\\n+ /// log(elem_value);\\n+ /// }\\n+ /// }\\n+ /// ```\\n+ #[storage(read)]\\n+ pub fn iter(self) -> StorageVecIter<V> {\\n+ StorageVecIter {\\n+ values: self,\\n+ len: self.len(),\\n+ index: 0,\\n+ }\\n+ }\\n+}\\n+\\n+#[cfg(experimental_dynamic_storage = true)]\\n+impl<V> Iterator for StorageVecIter<V> {\\n+ type Item = StorageKey<V>;\\n+ fn next(ref mut self) -> Option<Self::Item> {\\n+ if self.index >= self.len {\\n+ return None;\\n+ }\\n+\\n+ let storage_vec_field_id = self.values.field_id();\\n+\\n+ const STORES_STORAGE_TYPE: bool = __size_of::<V>() == 0;\\n+\\n+ let (offset, field_id) = if STORES_STORAGE_TYPE {\\n+ // For nested storage types, we know that they use a unique `field_id`\\n+ // set to `sha256((self.index, storage_vec_field_id)` that ensurs every\\n+ // nested storage type element will use it and store its content\\n+ // in a different slot.\\n+ (0, sha256((self.index, storage_vec_field_id)))\\n+ } else {\\n+ // For non-zero-sized types, we know that their values are\\n+ // stored in the `self.field_id()` slot.\\n+ (self.index * __size_of::<V>(), storage_vec_field_id)\\n+ };\\n+\\n+ let result = Some(StorageKey::<V>::new(storage_vec_field_id, offset, field_id));\\n+\\n+ self.index += 1;\\n+\\n+ result\\n+ }\\n }\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":"diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/array/array_repeat/stdout.snap b/test/src/e2e_vm_tests/test_programs/should_pass/language/array/array_repeat/stdout.snap\nindex 5178a69a0b8..1fcfe35878e 100644\n--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/array/array_repeat/stdout.snap\n+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/array/array_repeat/stdout.snap\n@@ -461,15 +461,15 @@ script {\n !111 = span !110 56851 56861\n !112 = fn_call_path_span !110 56856 56859\n !113 = \"test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-assert/src/raw_slice.sw\"\n-!114 = span !113 2922 2926\n+!114 = span !113 3680 3684\n !115 = (!108 !109 !111 !112 !114)\n-!116 = span !113 2911 2927\n-!117 = fn_call_path_span !113 2911 2921\n+!116 = span !113 3669 3685\n+!117 = fn_call_path_span !113 3669 3679\n !118 = (!108 !109 !111 !112 !116 !117)\n !119 = span !113 1633 1638\n !120 = (!108 !109 !111 !112 !116 !117 !119)\n !121 = (!108 !109 !111 !112)\n-!122 = span !113 2928 2929\n+!122 = span !113 3686 3687\n !123 = (!108 !109 !111 !112 !122)\n !124 = span !110 56830 56945\n !125 = (!108 !109 !124)\ndiff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm/storage_instructions/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm/storage_instructions/src/main.sw\nindex 20fd6965526..cecca353283 100644\n--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/asm/storage_instructions/src/main.sw\n+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/asm/storage_instructions/src/main.sw\n@@ -490,7 +490,7 @@ impl Contract {\n assert_eq(res, [42u64, 43u64, 44u64, 45u64, 46u64]);\n }\n \n- #[storage(read, write)]\n+ #[storage(write)]\n fn supd_offset_out_of_bounds() {\n let slots_data = [42u64, 43u64, 44u64, 45u64];\n let _ = __state_store_quad(B256_ZERO, __addr_of(slots_data), 1);\n@@ -539,6 +539,29 @@ impl Contract {\n assert_eq(res, [42u64, 43u64, 11u64, 12u64, 13u64]);\n }\n \n+ // Updating with zero length content does not change the slot.\n+ #[storage(read, write)]\n+ fn supd_occupied_slots_update_with_zero_length_content() {\n+ let slots_data = [42u64, 43u64, 44u64, 45u64];\n+ let _ = __state_store_quad(B256_ZERO, __addr_of(slots_data), 1);\n+\n+ assert_eq(32, __state_preload(B256_ZERO));\n+\n+ asm(slot: B256_ZERO, src: asm() { zero: raw_ptr }, offset: 3 * 8, len: 0) {\n+ supd slot src offset len;\n+ };\n+\n+ assert_eq(32, __state_preload(B256_ZERO));\n+\n+ let res = [0u64; 4];\n+ let is_err = asm(slot: B256_ZERO, res: __addr_of(res), offset: 0) {\n+ srdi res slot offset i32;\n+ err\n+ };\n+ assert_eq(is_err, 0);\n+ assert_eq(res, [42u64, 43u64, 44u64, 45u64]);\n+ }\n+\n // END: SUPD\n \n \n@@ -889,6 +912,12 @@ fn test_supd_occupied_slots_overwrite_and_extend() {\n caller.supd_occupied_slots_overwrite_and_extend();\n }\n \n+#[test]\n+fn test_supd_occupied_slots_update_with_zero_length_content() {\n+ let caller = abi(StorageInstructionsAbi, CONTRACT_ID);\n+ caller.supd_occupied_slots_update_with_zero_length_content();\n+}\n+\n #[test]\n fn test_supi_empty_slots_append() {\n let caller = abi(StorageInstructionsAbi, CONTRACT_ID);\ndiff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/intrinsics/storage_intrinsics/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/intrinsics/storage_intrinsics/src/main.sw\nindex 5bbe0e0d59c..09423c1799f 100644\n--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/intrinsics/storage_intrinsics/src/main.sw\n+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/intrinsics/storage_intrinsics/src/main.sw\n@@ -413,6 +413,7 @@ impl Contract {\n let val = [42u64, 43u64];\n let len = get_runtime_len(2 * 8);\n __state_store_slot(B256_ZERO, __addr_of(val), len);\n+ assert_eq(len, __state_preload(B256_ZERO));\n \n let res = [0u64; 2];\n let is_err = asm(slot: B256_ZERO, res: __addr_of(res), offset: 0) {\n@@ -425,6 +426,7 @@ impl Contract {\n // Overwrite.\n let val = [42u64, 43u64, 44u64, 45u64, 46u64, 47u64, 48u64, 49u64];\n __state_store_slot(B256_ZERO, __addr_of(val), 8 * 8);\n+ assert_eq(8 * 8, __state_preload(B256_ZERO));\n \n let res = [0u64; 8];\n let is_err = asm(slot: B256_ZERO, res: __addr_of(res), offset: 0, len: 8 * 8) {\n@@ -433,6 +435,11 @@ impl Contract {\n };\n assert_eq(is_err, 0);\n assert_eq(res, [42u64, 43u64, 44u64, 45u64, 46u64, 47u64, 48u64, 49u64]);\n+\n+ // Truncate to zero.\n+ let val: [u64;0] = [];\n+ __state_store_slot(B256_ZERO, __addr_of(val), 0);\n+ assert_eq(0, __state_preload(B256_ZERO));\n }\n \n // END: __state_store_slot\n@@ -599,7 +606,7 @@ impl Contract {\n assert_eq(res, [42u64, 43u64, 44u64, 45u64, 46u64]);\n }\n \n- #[storage(read, write)]\n+ #[storage(write)]\n fn state_update_slot_update_out_of_bounds() {\n let slots_data = [42u64, 43u64, 44u64, 45u64];\n __state_store_slot(B256_ZERO, __addr_of(slots_data), 4 * 8);\n@@ -678,10 +685,12 @@ fn get_runtime_len(len: u64) -> u64 {\n }\n \n // TODO-DCA: Fix false DCA warning for this function as a part of https://github.com/FuelLabs/sway/issues/5921.\n+#[allow(dead_code)]\n #[inline(never)]\n fn poke<T>(_t: T) { }\n \n // TODO-DCA: Fix false DCA warning for this function as a part of https://github.com/FuelLabs/sway/issues/5921.\n+#[allow(dead_code)]\n #[storage(read)]\n fn read_first_word_in_quod(slot: b256) -> (u64, u64) {\n let is_set_res = (0u64, 0u64);\ndiff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_various_types/stdout.snap b/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_various_types/stdout.snap\nindex 592f8fcfb4f..b6447080768 100644\n--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_various_types/stdout.snap\n+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/main_args/main_args_various_types/stdout.snap\n@@ -914,15 +914,15 @@ script {\n !79 = fn_call_path_span !4 60422 60425\n !80 = (!6 !7 !13 !14 !23 !24 !27 !28 !44 !45 !46 !47 !50 !51 !54 !55 !46 !47 !78 !79)\n !81 = \"sway-lib-std/src/raw_slice.sw\"\n-!82 = span !81 2922 2926\n+!82 = span !81 3680 3684\n !83 = (!6 !7 !13 !14 !23 !24 !27 !28 !44 !45 !46 !47 !50 !51 !54 !55 !46 !47 !78 !79 !82)\n-!84 = span !81 2911 2927\n-!85 = fn_call_path_span !81 2911 2921\n+!84 = span !81 3669 3685\n+!85 = fn_call_path_span !81 3669 3679\n !86 = (!6 !7 !13 !14 !23 !24 !27 !28 !44 !45 !46 !47 !50 !51 !54 !55 !46 !47 !78 !79 !84 !85)\n !87 = span !81 1633 1638\n !88 = (!6 !7 !13 !14 !23 !24 !27 !28 !44 !45 !46 !47 !50 !51 !54 !55 !46 !47 !78 !79 !84 !85 !87)\n !89 = (!6 !7 !13 !14 !23 !24 !27 !28 !44 !45 !46 !47 !50 !51 !54 !55 !46 !47 !78 !79)\n-!90 = span !81 2928 2929\n+!90 = span !81 3686 3687\n !91 = (!6 !7 !13 !14 !23 !24 !27 !28 !44 !45 !46 !47 !50 !51 !54 !55 !46 !47 !78 !79 !90)\n !92 = (!6 !7 !13 !14 !23 !24 !27 !28 !44 !45 !46 !47 !50 !51 !54 !55 !46 !47 !78 !79)\n !93 = (!6 !7 !13 !14 !23 !24 !27 !28 !44 !45 !46 !47 !50 !51 !52)\ndiff --git a/test/src/e2e_vm_tests/test_programs/should_pass/static_analysis/cei_pattern_violation_more_complex_logic/test.dynamic_storage.toml b/test/src/e2e_vm_tests/test_programs/should_pass/static_analysis/cei_pattern_violation_more_complex_logic/test.dynamic_storage.toml\nnew file mode 100644\nindex 00000000000..0b7b73d5d6f\n--- /dev/null\n+++ b/test/src/e2e_vm_tests/test_programs/should_pass/static_analysis/cei_pattern_violation_more_complex_logic/test.dynamic_storage.toml\n@@ -0,0 +1,9 @@\n+category = \"compile\"\n+experimental = { new_encoding = true, dynamic_storage = true }\n+\n+# check: $()Storage write after external contract interaction in function or method \"bid\". Consider making all storage writes before calling another contract\n+\n+# check: $()Storage read after external contract interaction in function or method \"create\". Consider making all storage reads before calling another contract\n+\n+# check: $()Storage write after external contract interaction in function or method \"create\". Consider making all storage writes before calling another contract\n+expected_warnings = 9\ndiff --git a/test/src/e2e_vm_tests/test_programs/should_pass/static_analysis/cei_pattern_violation_storage_map_and_vec/test.dynamic_storage.toml b/test/src/e2e_vm_tests/test_programs/should_pass/static_analysis/cei_pattern_violation_storage_map_and_vec/test.dynamic_storage.toml\nnew file mode 100644\nindex 00000000000..43fcee50ff1\n--- /dev/null\n+++ b/test/src/e2e_vm_tests/test_programs/should_pass/static_analysis/cei_pattern_violation_storage_map_and_vec/test.dynamic_storage.toml\n@@ -0,0 +1,6 @@\n+category = \"compile\"\n+experimental = { new_encoding = true, dynamic_storage = true }\n+\n+# check: $()Storage write after external contract interaction in function or method \"withdraw\". Consider making all storage writes before calling another contract\n+# check: $()Storage write after external contract interaction in function or method \"withdraw\". Consider making all storage writes before calling another contract\n+expected_warnings = 4\ndiff --git a/test/src/e2e_vm_tests/test_programs/should_pass/static_analysis/cei_pattern_violation_storage_struct_read/test.dynamic_storage.toml b/test/src/e2e_vm_tests/test_programs/should_pass/static_analysis/cei_pattern_violation_storage_struct_read/test.dynamic_storage.toml\nnew file mode 100644\nindex 00000000000..c51baecd0ad\n--- /dev/null\n+++ b/test/src/e2e_vm_tests/test_programs/should_pass/static_analysis/cei_pattern_violation_storage_struct_read/test.dynamic_storage.toml\n@@ -0,0 +1,6 @@\n+category = \"compile\"\n+experimental = { new_encoding = true, dynamic_storage = true }\n+expected_warnings = 4\n+\n+# check: $()Storage read after external contract interaction in function or method \"withdraw\". Consider making all storage reads before calling another contract\n+\ndiff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/storage_vec_insert/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/storage_vec_insert/Forc.lock\ndeleted file mode 100644\nindex 9e3852f7363..00000000000\n--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/storage_vec_insert/Forc.lock\n+++ /dev/null\n@@ -1,8 +0,0 @@\n-[[package]]\n-name = \"std\"\n-source = \"path+from-root-D63F86D6205FE44D\"\n-\n-[[package]]\n-name = \"storage_vec_insert\"\n-source = \"member\"\n-dependencies = [\"std\"]\ndiff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/storage_vec_insert/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/storage_vec_insert/Forc.toml\ndeleted file mode 100644\nindex d9eb1e3e6d6..00000000000\n--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/storage_vec_insert/Forc.toml\n+++ /dev/null\n@@ -1,9 +0,0 @@\n-[project]\n-authors = [\"Fuel Labs <contact@fuel.sh>\"]\n-entry = \"lib.sw\"\n-license = \"Apache-2.0\"\n-name = \"storage_vec_insert\"\n-implicit-std = false\n-\n-[dependencies]\n-std = { path = \"../../../../../../../sway-lib-std\" }\ndiff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/storage_vec_insert/src/lib.sw b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/storage_vec_insert/src/lib.sw\ndeleted file mode 100644\nindex 0236fde489f..00000000000\n--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/storage_vec_insert/src/lib.sw\n+++ /dev/null\n@@ -1,27 +0,0 @@\n-contract;\n-\n-use std::storage::storage_vec::*;\n-\n-abi MyContract {\n- #[storage(read, write)]\n- fn test_function() -> bool;\n-}\n-\n-storage {\n- foo: StorageVec<u32> = StorageVec {},\n-}\n-\n-impl MyContract for Contract {\n- #[storage(read, write)]\n- fn test_function() -> bool {\n- storage.foo.push(0);\n- storage.foo.insert(0, 123);\n- true\n- }\n-}\n-\n-#[test]\n-fn test_test_function() {\n- let caller = abi(MyContract, CONTRACT_ID);\n- let res: bool = caller.test_function();\n-}\n\\ No newline at end of file\ndiff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/storage_vec_insert/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/storage_vec_insert/test.toml\ndeleted file mode 100644\nindex 0f3f6d7e866..00000000000\n--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/storage_vec_insert/test.toml\n+++ /dev/null\n@@ -1,1 +0,0 @@\n-category = \"unit_tests_pass\"\ndiff --git a/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/storage_vec_s24/test.dynamic_storage.toml b/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/storage_vec_s24/test.dynamic_storage.toml\nnew file mode 100644\nindex 00000000000..f4927e655b1\n--- /dev/null\n+++ b/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/storage_vec_s24/test.dynamic_storage.toml\n@@ -0,0 +1,2 @@\n+category = \"unit_tests_pass\"\n+experimental = { new_encoding = true, dynamic_storage = true }\ndiff --git a/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/storage_vec_s32/test.dynamic_storage.toml b/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/storage_vec_s32/test.dynamic_storage.toml\nnew file mode 100644\nindex 00000000000..f4927e655b1\n--- /dev/null\n+++ b/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/storage_vec_s32/test.dynamic_storage.toml\n@@ -0,0 +1,2 @@\n+category = \"unit_tests_pass\"\n+experimental = { new_encoding = true, dynamic_storage = true }\ndiff --git a/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/storage_vec_s56/test.dynamic_storage.toml b/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/storage_vec_s56/test.dynamic_storage.toml\nnew file mode 100644\nindex 00000000000..f4927e655b1\n--- /dev/null\n+++ b/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/storage_vec_s56/test.dynamic_storage.toml\n@@ -0,0 +1,2 @@\n+category = \"unit_tests_pass\"\n+experimental = { new_encoding = true, dynamic_storage = true }\ndiff --git a/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/storage_vec_s72/test.dynamic_storage.toml b/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/storage_vec_s72/test.dynamic_storage.toml\nnew file mode 100644\nindex 00000000000..f4927e655b1\n--- /dev/null\n+++ b/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/storage_vec_s72/test.dynamic_storage.toml\n@@ -0,0 +1,2 @@\n+category = \"unit_tests_pass\"\n+experimental = { new_encoding = true, dynamic_storage = true }\ndiff --git a/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/storage_vec_s8/test.dynamic_storage.toml b/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/storage_vec_s8/test.dynamic_storage.toml\nnew file mode 100644\nindex 00000000000..f4927e655b1\n--- /dev/null\n+++ b/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/storage_vec_s8/test.dynamic_storage.toml\n@@ -0,0 +1,2 @@\n+category = \"unit_tests_pass\"\n+experimental = { new_encoding = true, dynamic_storage = true }\ndiff --git a/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/storage_vec_s88/test.dynamic_storage.toml b/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/storage_vec_s88/test.dynamic_storage.toml\nnew file mode 100644\nindex 00000000000..f4927e655b1\n--- /dev/null\n+++ b/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/storage_vec_s88/test.dynamic_storage.toml\n@@ -0,0 +1,2 @@\n+category = \"unit_tests_pass\"\n+experimental = { new_encoding = true, dynamic_storage = true }\ndiff --git a/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/storage_vec_s96/test.dynamic_storage.toml b/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/storage_vec_s96/test.dynamic_storage.toml\nnew file mode 100644\nindex 00000000000..f4927e655b1\n--- /dev/null\n+++ b/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/storage_vec_s96/test.dynamic_storage.toml\n@@ -0,0 +1,2 @@\n+category = \"unit_tests_pass\"\n+experimental = { new_encoding = true, dynamic_storage = true }\ndiff --git a/test/src/in_language_tests/Forc.toml b/test/src/in_language_tests/Forc.toml\nindex 6e75fed6a89..a2536264865 100644\n--- a/test/src/in_language_tests/Forc.toml\n+++ b/test/src/in_language_tests/Forc.toml\n@@ -1,59 +1,81 @@\n+# TODO: Use this workspace `Forc.toml` once https://github.com/FuelLabs/sway/issues/7613 is fixed.\n+# We might decide to generate this `Forc.toml` file on-the-fly or remove it altogether,\n+# depending on the outcome of https://github.com/FuelLabs/sway/issues/7617.\n+#\n+# Currently, we keep it because the `did_open_all_members_in_examples` test in `sway-lsp`\n+# requires it. Note that we still commented out storage tests. With them included, the\n+# `did_open_all_members_in_examples` runs a few minutes, compared to one minute when they\n+# are excluded, and the memory consumption jumps for ~10GB. The root cause is likely the\n+# same as in https://github.com/FuelLabs/sway/issues/7613.\n [workspace]\n members = [\n- \"test_programs/address_inline_tests\",\n- \"test_programs/alloc_inline_tests\",\n- \"test_programs/assert_inline_tests\",\n- \"test_programs/asset_id_inline_tests\",\n- \"test_programs/asset_id_contract_tests\",\n- \"test_programs/b512_inline_tests\",\n- \"test_programs/block_inline_tests\",\n- \"test_programs/bytes_inline_tests\",\n- \"test_programs/codec_implemented_tests\",\n- \"test_programs/contract_id_inline_tests\",\n- \"test_programs/contract_id_contract_tests\",\n- \"test_programs/crypto_point2d_inline_tests\",\n- \"test_programs/crypto_scalar_inline_tests\",\n- \"test_programs/crypto_zk_inline_tests\",\n- \"test_programs/crypto_ed25519_inline_tests\",\n- \"test_programs/crypto_message_inline_tests\",\n- \"test_programs/crypto_public_key_inline_tests\",\n- \"test_programs/crypto_secp256k1_inline_tests\",\n- \"test_programs/crypto_secp256r1_inline_tests\",\n- \"test_programs/crypto_signature_inline_tests\",\n- \"test_programs/ecr_inline_tests\",\n- \"test_programs/flags_inline_tests\",\n- \"test_programs/hash_inline_tests\",\n- \"test_programs/identity_inline_tests\",\n- \"test_programs/math_inline_tests\",\n- \"test_programs/option_inline_tests\",\n- \"test_programs/output_inline_tests\",\n- \"test_programs/result_inline_tests\",\n- \"test_programs/revert_inline_tests\",\n- \"test_programs/storage_key_inline_tests\",\n- \"test_programs/storage_vec_iter_tests\",\n- \"test_programs/string_inline_tests\",\n- \"test_programs/time_inline_tests\",\n- \"test_programs/tx_inline_tests\",\n- \"test_programs/u128_inline_tests\",\n- \"test_programs/vec_inline_tests\",\n- \"test_programs/array_conversions_b256_inline_tests\",\n- \"test_programs/array_conversions_u16_inline_tests\",\n- \"test_programs/array_conversions_u32_inline_tests\",\n- \"test_programs/array_conversions_u64_inline_tests\",\n- \"test_programs/array_conversions_u256_inline_tests\",\n- \"test_programs/bytes_conversions_b256_inline_tests\",\n- \"test_programs/bytes_conversions_u16_inline_tests\",\n- \"test_programs/bytes_conversions_u32_inline_tests\",\n- \"test_programs/bytes_conversions_u64_inline_tests\",\n- \"test_programs/bytes_conversions_u256_inline_tests\",\n- \"test_programs/primitive_conversions_b256_inline_tests\",\n- \"test_programs/primitive_conversions_str_inline_tests\",\n- \"test_programs/primitive_conversions_u8_inline_tests\",\n- \"test_programs/primitive_conversions_u16_inline_tests\",\n- \"test_programs/primitive_conversions_u32_inline_tests\",\n- \"test_programs/primitive_conversions_u64_inline_tests\",\n- \"test_programs/primitive_conversions_u256_inline_tests\",\n- \"test_programs/vm_evm_evm_address_inline_tests\",\n- \"test_programs/vm_evm_ecr_inline_tests\",\n- \"test_programs/ops_inline_tests\",\n+\"test_programs/address_inline_tests\",\n+\"test_programs/alloc_inline_tests\",\n+\"test_programs/assert_inline_tests\",\n+\"test_programs/asset_id_inline_tests\",\n+\"test_programs/asset_id_contract_tests\",\n+\"test_programs/b512_inline_tests\",\n+\"test_programs/block_inline_tests\",\n+\"test_programs/bytes_inline_tests\",\n+\"test_programs/codec_implemented_inline_tests\",\n+\"test_programs/contract_id_inline_tests\",\n+\"test_programs/contract_id_contract_tests\",\n+\"test_programs/crypto_point2d_inline_tests\",\n+\"test_programs/crypto_scalar_inline_tests\",\n+\"test_programs/crypto_zk_inline_tests\",\n+\"test_programs/crypto_ed25519_inline_tests\",\n+\"test_programs/crypto_message_inline_tests\",\n+\"test_programs/crypto_public_key_inline_tests\",\n+\"test_programs/crypto_secp256k1_inline_tests\",\n+\"test_programs/crypto_secp256r1_inline_tests\",\n+\"test_programs/crypto_signature_inline_tests\",\n+\"test_programs/ecr_inline_tests\",\n+\"test_programs/flags_inline_tests\",\n+\"test_programs/hash_inline_tests\",\n+\"test_programs/identity_inline_tests\",\n+\"test_programs/math_inline_tests\",\n+\"test_programs/option_inline_tests\",\n+\"test_programs/output_inline_tests\",\n+\"test_programs/result_inline_tests\",\n+\"test_programs/revert_inline_tests\",\n+\"test_programs/storage_key_inline_tests\",\n+# \"test_programs/storage_key_contract_tests\",\n+# \"test_programs/storage_vec_fill_contract_tests\",\n+# \"test_programs/storage_vec_insert_contract_tests\",\n+# \"test_programs/storage_vec_iter_contract_tests\",\n+# \"test_programs/storage_vec_load_vec_contract_tests\",\n+# \"test_programs/storage_vec_of_storage_vec_contract_tests\",\n+# \"test_programs/storage_vec_push_pop_get_len_first_last_is_empty_contract_tests\",\n+# \"test_programs/storage_vec_remove_contract_tests\",\n+# \"test_programs/storage_vec_resize_contract_tests\",\n+# \"test_programs/storage_vec_reverse_contract_tests\",\n+# \"test_programs/storage_vec_set_contract_tests\",\n+# \"test_programs/storage_vec_store_vec_contract_tests\",\n+# \"test_programs/storage_vec_swap_contract_tests\",\n+# \"test_programs/storage_vec_swap_remove_contract_tests\",\n+\"test_programs/string_inline_tests\",\n+\"test_programs/time_inline_tests\",\n+\"test_programs/tx_inline_tests\",\n+\"test_programs/u128_inline_tests\",\n+\"test_programs/vec_inline_tests\",\n+\"test_programs/array_conversions_b256_inline_tests\",\n+\"test_programs/array_conversions_u16_inline_tests\",\n+\"test_programs/array_conversions_u32_inline_tests\",\n+\"test_programs/array_conversions_u64_inline_tests\",\n+\"test_programs/array_conversions_u256_inline_tests\",\n+\"test_programs/bytes_conversions_b256_inline_tests\",\n+\"test_programs/bytes_conversions_u16_inline_tests\",\n+\"test_programs/bytes_conversions_u32_inline_tests\",\n+\"test_programs/bytes_conversions_u64_inline_tests\",\n+\"test_programs/bytes_conversions_u256_inline_tests\",\n+\"test_programs/primitive_conversions_b256_inline_tests\",\n+\"test_programs/primitive_conversions_str_inline_tests\",\n+\"test_programs/primitive_conversions_u8_inline_tests\",\n+\"test_programs/primitive_conversions_u16_inline_tests\",\n+\"test_programs/primitive_conversions_u32_inline_tests\",\n+\"test_programs/primitive_conversions_u64_inline_tests\",\n+\"test_programs/primitive_conversions_u256_inline_tests\",\n+\"test_programs/vm_evm_evm_address_inline_tests\",\n+\"test_programs/vm_evm_ecr_inline_tests\",\n+\"test_programs/ops_inline_tests\",\n ]\ndiff --git a/test/src/in_language_tests/run_in_language_tests.sh b/test/src/in_language_tests/run_in_language_tests.sh\nnew file mode 100755\nindex 00000000000..d09239e82e1\n--- /dev/null\n+++ b/test/src/in_language_tests/run_in_language_tests.sh\n@@ -0,0 +1,71 @@\n+#!/usr/bin/env bash\n+\n+# Run `forc test` individually for each project under test_programs/.\n+#\n+# Usage: ./run_in_language_tests.sh [extra `forc test` args, e.g. --release --experimental ...]\n+#\n+# Note: --error-on-warnings arg is always passed to `forc test`.\n+#\n+# The script continues even when individual test projects fail, and exits with\n+# a non-zero code at the end if any project failed.\n+\n+# TODO: This is a workaround for the issue of `forc test` process getting killed\n+# when running tests on a workspace with large number of projects.\n+# Remove this file and switch to using `forc test` on the entire workspace\n+# once https://github.com/FuelLabs/sway/issues/7613 is resolved.\n+\n+SCRIPT_DIR=\"$(cd \"$(dirname \"${BASH_SOURCE[0]}\")\" && pwd)\"\n+TEST_PROGRAMS_DIR=\"$SCRIPT_DIR/test_programs\"\n+\n+# Always use the `forc` binary built in the repository root (3 levels above here:\n+# test/src/in_language_tests/ -> sway/).\n+REPO_ROOT=\"$(cd \"$SCRIPT_DIR/../../..\" && pwd)\"\n+FORC=\"$REPO_ROOT/target/release/forc\"\n+if [[ ! -x \"$FORC\" ]]; then\n+ echo \"Error: \\`forc\\` binary not found at $FORC\" >&2\n+ echo \"Build it with: cargo build --release -p forc\" >&2\n+ exit 1\n+fi\n+\n+# Projects under test_programs/ that are not test projects and should be skipped.\n+EXCLUDED_PROJECTS=(\n+ \"test_types\"\n+)\n+\n+failed=()\n+passed=()\n+\n+while IFS= read -r -d '' forc_toml; do\n+ project_dir=\"$(dirname \"$forc_toml\")\"\n+ project_name=\"$(basename \"$project_dir\")\"\n+\n+ if [[ \" ${EXCLUDED_PROJECTS[*]} \" == *\" ${project_name} \"* ]]; then\n+ continue\n+ fi\n+\n+ echo \"\"\n+ echo \"==> Testing: $project_name\"\n+\n+ if \"$FORC\" test --error-on-warnings \"$@\" --path \"$project_dir\"; then\n+ passed+=(\"$project_name\")\n+ else\n+ echo \"FAILED: $project_name\" >&2\n+ failed+=(\"$project_name\")\n+ fi\n+done < <(find \"$TEST_PROGRAMS_DIR\" -mindepth 2 -maxdepth 2 -name \"Forc.toml\" -print0 | sort -z)\n+\n+echo \"\"\n+echo \"================================================\"\n+echo \"Results: ${#passed[@]} passed, ${#failed[@]} failed\"\n+echo \"================================================\"\n+\n+if [[ ${#failed[@]} -gt 0 ]]; then\n+ echo \"\"\n+ echo \"Failed tests (${#failed[@]}):\"\n+ for f in \"${failed[@]}\"; do\n+ echo \" - $f\"\n+ done\n+ exit 1\n+fi\n+\n+echo \"All ${#passed[@]} tests passed!\"\ndiff --git a/test/src/sdk-harness/test_projects/storage_vec_nested/Forc.toml b/test/src/in_language_tests/test_programs/codec_implemented_inline_tests/Forc.toml\nsimilarity index 79%\nrename from test/src/sdk-harness/test_projects/storage_vec_nested/Forc.toml\nrename to test/src/in_language_tests/test_programs/codec_implemented_inline_tests/Forc.toml\nindex 99675ba5ae4..588e65d0296 100644\n--- a/test/src/sdk-harness/test_projects/storage_vec_nested/Forc.toml\n+++ b/test/src/in_language_tests/test_programs/codec_implemented_inline_tests/Forc.toml\n@@ -2,7 +2,7 @@\n authors = [\"Fuel Labs <contact@fuel.sh>\"]\n entry = \"main.sw\"\n license = \"Apache-2.0\"\n-name = \"storage_vec_nested\"\n+name = \"codec_implemented_inline_tests\"\n \n [dependencies]\n std = { path = \"../../../../../sway-lib-std\" }\ndiff --git a/test/src/in_language_tests/test_programs/codec_implemented_tests/src/main.sw b/test/src/in_language_tests/test_programs/codec_implemented_inline_tests/src/main.sw\nsimilarity index 79%\nrename from test/src/in_language_tests/test_programs/codec_implemented_tests/src/main.sw\nrename to test/src/in_language_tests/test_programs/codec_implemented_inline_tests/src/main.sw\nindex c1c7495f671..f2b498afc63 100644\n--- a/test/src/in_language_tests/test_programs/codec_implemented_tests/src/main.sw\n+++ b/test/src/in_language_tests/test_programs/codec_implemented_inline_tests/src/main.sw\n@@ -1,7 +1,6 @@\n+//! Log every type defined in the `std` to ensure encoding is implemented for them.\n library;\n-// Logs every new type defined in the std lib to ensure codec is working for them\n \n-#[cfg(experimental_dynamic_storage = false)]\n use std::{\n logging::log,\n address::Address,\n@@ -49,7 +48,6 @@ use std::{\n },\n };\n \n-#[cfg(experimental_dynamic_storage = false)]\n #[test]\n fn test_logging() {\n log(Address::zero());\n@@ -65,13 +63,10 @@ fn test_logging() {\n log(SignatureError::UnrecoverablePublicKey);\n log(Signature::Secp256k1(Secp256k1::new()));\n log(StorageBytes {});\n- let skey: StorageKey<u64> = StorageKey::new(b256::zero(), 0, b256::zero());\n- log(skey);\n- let smap: StorageMap<u64, u64> = StorageMap {};\n- log(smap);\n+ log(StorageKey::<u64>::new(b256::zero(), 0, b256::zero()));\n+ log(StorageMap::<u64, u64> {});\n log(StorageString {});\n- let svec: StorageVec<u64> = StorageVec {};\n- log(svec);\n+ log(StorageVec::<u64> {});\n log(EvmAddress::zero());\n log(SubId::zero());\n log(Vec::<u64>::new());\n@@ -85,11 +80,9 @@ fn test_logging() {\n log(Identity::Address(Address::zero()));\n log(Input::Coin);\n log(CallParams{coins: 0, asset_id: AssetId::zero(), gas: 0});\n- let option: Option<u64> = Option::Some(0);\n- log(option);\n+ log(Option::<u64>::Some(0));\n log(Output::Coin);\n- let res: Result<u64, u64> = Result::Ok(0);\n- log(res);\n+ log(Result::<u64, u64>::Ok(0));\n log(String::new());\n log(Transaction::Script);\n log(U128::zero());\ndiff --git a/test/src/in_language_tests/test_programs/codec_implemented_tests/Forc.toml b/test/src/in_language_tests/test_programs/storage_key_contract_tests/Forc.toml\nsimilarity index 67%\nrename from test/src/in_language_tests/test_programs/codec_implemented_tests/Forc.toml\nrename to test/src/in_language_tests/test_programs/storage_key_contract_tests/Forc.toml\nindex 16cdb6e9c04..ef28c6249e9 100644\n--- a/test/src/in_language_tests/test_programs/codec_implemented_tests/Forc.toml\n+++ b/test/src/in_language_tests/test_programs/storage_key_contract_tests/Forc.toml\n@@ -2,7 +2,8 @@\n authors = [\"Fuel Labs <contact@fuel.sh>\"]\n entry = \"main.sw\"\n license = \"Apache-2.0\"\n-name = \"codec_implemented_tests\"\n+name = \"storage_key_contract_tests\"\n \n [dependencies]\n std = { path = \"../../../../../sway-lib-std\" }\n+test_types = { path = \"../test_types\" }\ndiff --git a/test/src/in_language_tests/test_programs/storage_key_contract_tests/src/main.sw b/test/src/in_language_tests/test_programs/storage_key_contract_tests/src/main.sw\nnew file mode 100644\nindex 00000000000..f3c231f0893\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_key_contract_tests/src/main.sw\n@@ -0,0 +1,114 @@\n+// TODO: Replace `assert(x == y)` back with `assert_eq(x, y)` once `assert_eq` no longer\n+// causes data-section explosion. See also: https://github.com/FuelLabs/sway/issues/7612\n+contract;\n+\n+use test_types::*;\n+\n+use std::hash::{Hash, sha256};\n+\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+#[cfg(experimental_dynamic_storage = false)]\n+#[storage(read, write)]\n+fn assert_clear_clear_existed_impl<T>(key: StorageKey<T>)\n+where\n+ T: Eq + TestInstance + AbiEncode,\n+{\n+ let existed = key.clear();\n+ assert(existed);\n+ assert(key.try_read().is_none());\n+ let existed_again = key.clear();\n+ assert(!existed_again);\n+}\n+\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+#[cfg(experimental_dynamic_storage = true)]\n+#[storage(read, write)]\n+fn assert_clear_clear_existed_impl<T>(key: StorageKey<T>)\n+where\n+ T: Eq + TestInstance + AbiEncode,\n+{\n+ let existed = key.clear_existed();\n+ assert(existed);\n+ assert(key.try_read().is_none());\n+\n+ let existed_again = key.clear_existed();\n+ assert(!existed_again);\n+\n+ key.write(T::typical_value());\n+ key.clear();\n+ assert(key.try_read().is_none());\n+}\n+\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+#[storage(read, write)]\n+fn assert_write_read_try_read_clear_clear_existed_impl<T>(slot_id_preimage: u64)\n+where\n+ T: Eq + TestInstance + AbiEncode,\n+{\n+ assert_non_zero_sized_type::<T>();\n+\n+ let key: StorageKey<T> = StorageKey::new(sha256(slot_id_preimage), 0, sha256(slot_id_preimage));\n+\n+ assert(key.try_read().is_none());\n+\n+ key.write(T::typical_value());\n+ assert(key.read() == T::typical_value());\n+ assert(key.try_read() == Some(T::typical_value()));\n+\n+ assert_clear_clear_existed_impl(key);\n+}\n+\n+impl Contract {\n+ // Note that zero-sized types like, e.g., `()`, `[u64;0]`, or `EmptyStruct`,\n+ // by definition of the storage access semantics, cannot be stored in\n+ // a `StorageVec<T>`. If the `T` is zero-sized it must be an another\n+ // nested storage type, e.g., `StorageVec<StorageMap<u64, b256>>`.\n+ // So, in all the tests below, we don't have zero-sized types.\n+\n+ #[storage(read, write)]\n+ fn assert_write_read_try_read_clear_clear_existed() {\n+ assert_write_read_try_read_clear_clear_existed_impl::<bool>(1);\n+ assert_write_read_try_read_clear_clear_existed_impl::<u8>(2);\n+ assert_write_read_try_read_clear_clear_existed_impl::<u16>(3);\n+ assert_write_read_try_read_clear_clear_existed_impl::<u32>(4);\n+ assert_write_read_try_read_clear_clear_existed_impl::<u64>(5);\n+ assert_write_read_try_read_clear_clear_existed_impl::<u256>(6);\n+ assert_write_read_try_read_clear_clear_existed_impl::<b256>(7);\n+ assert_write_read_try_read_clear_clear_existed_impl::<raw_slice>(8);\n+ assert_write_read_try_read_clear_clear_existed_impl::<str>(9);\n+ assert_write_read_try_read_clear_clear_existed_impl::<str[2]>(10);\n+ assert_write_read_try_read_clear_clear_existed_impl::<str[5]>(11);\n+ assert_write_read_try_read_clear_clear_existed_impl::<str[6]>(12);\n+ assert_write_read_try_read_clear_clear_existed_impl::<str[8]>(13);\n+ assert_write_read_try_read_clear_clear_existed_impl::<str[12]>(14);\n+ assert_write_read_try_read_clear_clear_existed_impl::<str[13]>(15);\n+ assert_write_read_try_read_clear_clear_existed_impl::<[u64; 2]>(16);\n+ assert_write_read_try_read_clear_clear_existed_impl::<ArrayU8Len2>(17);\n+ assert_write_read_try_read_clear_clear_existed_impl::<ArrayU8Len5>(18);\n+ assert_write_read_try_read_clear_clear_existed_impl::<ArrayU8Len6>(19);\n+ assert_write_read_try_read_clear_clear_existed_impl::<ArrayU8Len8>(20);\n+ assert_write_read_try_read_clear_clear_existed_impl::<ArrayU8Len12>(21);\n+ assert_write_read_try_read_clear_clear_existed_impl::<ArrayU8Len13>(22);\n+ assert_write_read_try_read_clear_clear_existed_impl::<ArrayU64Len3>(23);\n+ assert_write_read_try_read_clear_clear_existed_impl::<ArrayNestedArrayU8Len2Len3>(24);\n+ assert_write_read_try_read_clear_clear_existed_impl::<ArrayStructBLen2>(25);\n+ assert_write_read_try_read_clear_clear_existed_impl::<RawPtrNewtype>(26);\n+ assert_write_read_try_read_clear_clear_existed_impl::<StructA>(27);\n+ assert_write_read_try_read_clear_clear_existed_impl::<StructB>(28);\n+ assert_write_read_try_read_clear_clear_existed_impl::<EnumSingleU8>(29);\n+ assert_write_read_try_read_clear_clear_existed_impl::<EnumSingleU64>(30);\n+ assert_write_read_try_read_clear_clear_existed_impl::<EnumSingleBool>(31);\n+ assert_write_read_try_read_clear_clear_existed_impl::<EnumMultiUnits>(32);\n+ assert_write_read_try_read_clear_clear_existed_impl::<EnumMultiOneByte>(33);\n+ assert_write_read_try_read_clear_clear_existed_impl::<EnumU8AndU64>(34);\n+ assert_write_read_try_read_clear_clear_existed_impl::<EnumQuadSlotSize>(35);\n+ assert_write_read_try_read_clear_clear_existed_impl::<EnumLargerThanQuadSlot>(36);\n+ assert_write_read_try_read_clear_clear_existed_impl::<(u8, u32)>(37);\n+ }\n+}\n+\n+#[test]\n+fn write_read_try_read_clear_clear_existed() {\n+ let caller = abi(StorageKeyContractTestsAbi, CONTRACT_ID);\n+ caller.assert_write_read_try_read_clear_clear_existed();\n+}\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_fill_contract_tests/Forc.toml b/test/src/in_language_tests/test_programs/storage_vec_fill_contract_tests/Forc.toml\nnew file mode 100644\nindex 00000000000..27b91ae5483\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_vec_fill_contract_tests/Forc.toml\n@@ -0,0 +1,9 @@\n+[project]\n+authors = [\"Fuel Labs <contact@fuel.sh>\"]\n+entry = \"main.sw\"\n+license = \"Apache-2.0\"\n+name = \"storage_vec_fill_contract_tests\"\n+\n+[dependencies]\n+std = { path = \"../../../../../sway-lib-std\" }\n+test_types = { path = \"../test_types\" }\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_fill_contract_tests/src/main.sw b/test/src/in_language_tests/test_programs/storage_vec_fill_contract_tests/src/main.sw\nnew file mode 100644\nindex 00000000000..43292c411e3\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_vec_fill_contract_tests/src/main.sw\n@@ -0,0 +1,128 @@\n+// TODO: The initial reason for having several `storage_vec` tests is\n+// reaching the limit in the data section size of a single contract\n+// that contained all the tests for `StorageVec<T>` methods.\n+// See: https://github.com/FuelLabs/sway/issues/7612\n+// But even when the issue is solved, it perhaps still makes sense to have\n+// separate test projects for better organization and readability\n+// of the tests.\n+// TODO: Replace `assert(x == y)` back with `assert_eq(x, y)` once `assert_eq` no longer\n+// causes data-section explosion. See also: https://github.com/FuelLabs/sway/issues/7612\n+contract;\n+\n+use test_types::*;\n+\n+use std::hash::{Hash, sha256};\n+use std::storage::storage_vec::*;\n+\n+/// Default number of vector elements to use in tests.\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+const NUM_OF_ELEMENTS: u64 = 11;\n+\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+#[storage(read, write)]\n+fn assert_fill_impl<T>(\n+ slot_id_preimage: u64,\n+)\n+where\n+ T: Eq + TestInstance + AbiEncode,\n+{\n+ assert_non_zero_sized_type::<T>();\n+\n+ let vec: StorageKey<StorageVec<T>> = StorageKey::new(sha256(slot_id_preimage), 0, sha256(slot_id_preimage + 100));\n+\n+ let expected_values = T::instances(NUM_OF_ELEMENTS);\n+\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ vec.push(expected_values.get(i).unwrap());\n+ i += 1;\n+ }\n+\n+ let fill_value = expected_values.get(NUM_OF_ELEMENTS / 2).unwrap();\n+ vec.fill(fill_value);\n+ assert(NUM_OF_ELEMENTS == vec.len());\n+\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ assert(fill_value == vec.get(i).unwrap().read());\n+ i += 1;\n+ }\n+\n+ // Filling empty and single-element vectors should be a no-op / simple overwrite.\n+ let _ = vec.clear();\n+ vec.fill(fill_value);\n+ assert(0 == vec.len());\n+\n+ vec.push(expected_values.get(0).unwrap());\n+ vec.fill(fill_value);\n+ assert(1 == vec.len());\n+ assert(fill_value == vec.get(0).unwrap().read());\n+}\n+\n+impl Contract {\n+ // Note that zero-sized types like, e.g., `()`, `[u64;0]`, or `EmptyStruct`,\n+ // by definition of the storage access semantics, cannot be stored in\n+ // a `StorageVec<T>`. If the `T` is zero-sized it must be an another\n+ // nested storage type, e.g., `StorageVec<StorageMap<u64, b256>>`.\n+ // So, in all the tests below, we don't have zero-sized types.\n+\n+ #[storage(read, write)]\n+ fn assert_fill() {\n+ assert_fill_impl::<bool>(1);\n+ assert_fill_impl::<u8>(2);\n+ assert_fill_impl::<u16>(3);\n+ assert_fill_impl::<u32>(4);\n+ assert_fill_impl::<u64>(5);\n+ assert_fill_impl::<u256>(6);\n+ assert_fill_impl::<b256>(7);\n+ assert_fill_impl::<raw_slice>(8);\n+ assert_fill_impl::<str>(9);\n+ assert_fill_impl::<str[2]>(10);\n+ assert_fill_impl::<str[5]>(11);\n+ assert_fill_impl::<str[6]>(12);\n+ assert_fill_impl::<str[8]>(13);\n+ assert_fill_impl::<str[12]>(14);\n+ assert_fill_impl::<str[13]>(15);\n+ assert_fill_impl::<[u64; 2]>(16);\n+ assert_fill_impl::<ArrayU8Len2>(17);\n+ assert_fill_impl::<ArrayU8Len5>(18);\n+ assert_fill_impl::<ArrayU8Len6>(19);\n+ assert_fill_impl::<ArrayU8Len8>(20);\n+ assert_fill_impl::<ArrayU8Len12>(21);\n+ assert_fill_impl::<ArrayU8Len13>(22);\n+ assert_fill_impl::<ArrayU64Len3>(23);\n+ assert_fill_impl::<ArrayNestedArrayU8Len2Len3>(24);\n+ assert_fill_impl::<ArrayStructBLen2>(25);\n+ assert_fill_impl::<RawPtrNewtype>(26);\n+ assert_fill_impl::<StructA>(27);\n+ assert_fill_impl::<StructB>(28);\n+ assert_fill_impl::<EnumSingleU8>(29);\n+ assert_fill_impl::<EnumSingleU64>(30);\n+ assert_fill_impl::<EnumSingleBool>(31);\n+ assert_fill_impl::<EnumMultiUnits>(32);\n+ assert_fill_impl::<EnumMultiOneByte>(33);\n+ assert_fill_impl::<EnumU8AndU64>(34);\n+ assert_fill_impl::<EnumQuadSlotSize>(35);\n+ assert_fill_impl::<EnumLargerThanQuadSlot>(36);\n+ assert_fill_impl::<(u8, u32)>(37);\n+ }\n+\n+ #[storage(write)]\n+ fn assert_fill_nested_storage_type() {\n+ let vec: StorageKey<StorageVec<StorageVec<u64>>> = StorageKey::new(b256::zero(), 0, b256::zero());\n+ vec.fill(StorageVec {}); // Nested storage types cannot be filled.\n+ }\n+\n+}\n+\n+#[test]\n+fn fill() {\n+ let caller = abi(StorageVecFillContractTestsAbi, CONTRACT_ID);\n+ caller.assert_fill();\n+}\n+\n+#[test(should_revert)]\n+fn fill_nested_storage_type() {\n+ let caller = abi(StorageVecFillContractTestsAbi, CONTRACT_ID);\n+ caller.assert_fill_nested_storage_type();\n+}\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_insert_contract_tests/Forc.toml b/test/src/in_language_tests/test_programs/storage_vec_insert_contract_tests/Forc.toml\nnew file mode 100644\nindex 00000000000..fe8160f75fb\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_vec_insert_contract_tests/Forc.toml\n@@ -0,0 +1,9 @@\n+[project]\n+authors = [\"Fuel Labs <contact@fuel.sh>\"]\n+entry = \"main.sw\"\n+license = \"Apache-2.0\"\n+name = \"storage_vec_insert_contract_tests\"\n+\n+[dependencies]\n+std = { path = \"../../../../../sway-lib-std\" }\n+test_types = { path = \"../test_types\" }\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_insert_contract_tests/src/main.sw b/test/src/in_language_tests/test_programs/storage_vec_insert_contract_tests/src/main.sw\nnew file mode 100644\nindex 00000000000..d523111a552\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_vec_insert_contract_tests/src/main.sw\n@@ -0,0 +1,179 @@\n+// TODO: The initial reason for having several `storage_vec` tests is\n+// reaching the limit in the data section size of a single contract\n+// that contained all the tests for `StorageVec<T>` methods.\n+// See: https://github.com/FuelLabs/sway/issues/7612\n+// But even when the issue is solved, it perhaps still makes sense to have\n+// separate test projects for better organization and readability\n+// of the tests.\n+// TODO: Replace `assert(x == y)` back with `assert_eq(x, y)` once `assert_eq` no longer\n+// causes data-section explosion. See also: https://github.com/FuelLabs/sway/issues/7612\n+contract;\n+\n+use test_types::*;\n+\n+use std::hash::{Hash, sha256};\n+use std::storage::storage_vec::*;\n+\n+/// Default number of vector elements to use in tests.\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+const NUM_OF_ELEMENTS: u64 = 11;\n+\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+#[storage(read, write)]\n+fn assert_insert_impl<T>(\n+ slot_id_preimage: u64,\n+)\n+where\n+ T: Eq + TestInstance + AbiEncode,\n+{\n+ assert_non_zero_sized_type::<T>();\n+\n+ let vec: StorageKey<StorageVec<T>> = StorageKey::new(sha256(slot_id_preimage), 0, sha256(slot_id_preimage + 100));\n+\n+ let expected_values = T::instances(NUM_OF_ELEMENTS);\n+\n+ // Append instances.\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ vec.insert(i, expected_values.get(i).unwrap());\n+ assert(expected_values.get(i) == vec.get(i).unwrap().try_read());\n+ assert(i + 1 == vec.len());\n+ i += 1;\n+ }\n+\n+ assert(NUM_OF_ELEMENTS == vec.len());\n+\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ assert(expected_values.get(i) == vec.get(i).unwrap().try_read());\n+ i += 1;\n+ }\n+\n+ // Insert front element and verify right shift.\n+ let inserted_front = T::default();\n+ vec.insert(0, inserted_front);\n+ assert(NUM_OF_ELEMENTS + 1 == vec.len());\n+ assert(inserted_front == vec.get(0).unwrap().read());\n+ assert(expected_values.get(0) == vec.get(1).unwrap().try_read());\n+\n+ // Insert middle element and verify right shift around inserted index.\n+ let inserted_middle = expected_values.get(NUM_OF_ELEMENTS / 2).unwrap();\n+ let middle_index = vec.len() / 2;\n+ let old_middle = vec.get(middle_index).unwrap().try_read();\n+ vec.insert(middle_index, inserted_middle);\n+ assert(NUM_OF_ELEMENTS + 2 == vec.len());\n+ assert(inserted_middle == vec.get(middle_index).unwrap().read());\n+ assert(old_middle == vec.get(middle_index + 1).unwrap().try_read());\n+\n+ // Insert last element and verify it is appended correctly.\n+ let inserted_end = expected_values.get(NUM_OF_ELEMENTS - 1).unwrap();\n+ vec.insert(vec.len(), inserted_end);\n+ assert(NUM_OF_ELEMENTS + 3 == vec.len());\n+ assert(inserted_end == vec.last().unwrap().read());\n+\n+ // Verify full expected sequence after all insertions.\n+ let mut expected_after_insertions = Vec::new();\n+ expected_after_insertions.push(inserted_front);\n+\n+ let mut i = 0;\n+ while i < middle_index - 1 {\n+ expected_after_insertions.push(expected_values.get(i).unwrap());\n+ i += 1;\n+ }\n+\n+ expected_after_insertions.push(inserted_middle);\n+\n+ let mut i = middle_index - 1;\n+ while i < NUM_OF_ELEMENTS {\n+ expected_after_insertions.push(expected_values.get(i).unwrap());\n+ i += 1;\n+ }\n+\n+ expected_after_insertions.push(inserted_end);\n+\n+ let mut i = 0;\n+ while i < expected_after_insertions.len() {\n+ assert(expected_after_insertions.get(i) == vec.get(i).unwrap().try_read());\n+ i += 1;\n+ }\n+}\n+\n+impl Contract {\n+ // Note that zero-sized types like, e.g., `()`, `[u64;0]`, or `EmptyStruct`,\n+ // by definition of the storage access semantics, cannot be stored in\n+ // a `StorageVec<T>`. If the `T` is zero-sized it must be an another\n+ // nested storage type, e.g., `StorageVec<StorageMap<u64, b256>>`.\n+ // So, in all the tests below, we don't have zero-sized types.\n+\n+ #[storage(read, write)]\n+ fn assert_insert() {\n+ assert_insert_impl::<bool>(1);\n+ assert_insert_impl::<u8>(2);\n+ assert_insert_impl::<u16>(3);\n+ assert_insert_impl::<u32>(4);\n+ assert_insert_impl::<u64>(5);\n+ assert_insert_impl::<u256>(6);\n+ assert_insert_impl::<b256>(7);\n+ assert_insert_impl::<raw_slice>(8);\n+ assert_insert_impl::<str>(9);\n+ assert_insert_impl::<str[2]>(10);\n+ assert_insert_impl::<str[5]>(11);\n+ assert_insert_impl::<str[6]>(12);\n+ assert_insert_impl::<str[8]>(13);\n+ assert_insert_impl::<str[12]>(14);\n+ assert_insert_impl::<str[13]>(15);\n+ assert_insert_impl::<[u64; 2]>(16);\n+ assert_insert_impl::<ArrayU8Len2>(17);\n+ assert_insert_impl::<ArrayU8Len5>(18);\n+ assert_insert_impl::<ArrayU8Len6>(19);\n+ assert_insert_impl::<ArrayU8Len8>(20);\n+ assert_insert_impl::<ArrayU8Len12>(21);\n+ assert_insert_impl::<ArrayU8Len13>(22);\n+ assert_insert_impl::<ArrayU64Len3>(23);\n+ assert_insert_impl::<ArrayNestedArrayU8Len2Len3>(24);\n+ assert_insert_impl::<ArrayStructBLen2>(25);\n+ assert_insert_impl::<RawPtrNewtype>(26);\n+ assert_insert_impl::<StructA>(27);\n+ assert_insert_impl::<StructB>(28);\n+ assert_insert_impl::<EnumSingleU8>(29);\n+ assert_insert_impl::<EnumSingleU64>(30);\n+ assert_insert_impl::<EnumSingleBool>(31);\n+ assert_insert_impl::<EnumMultiUnits>(32);\n+ assert_insert_impl::<EnumMultiOneByte>(33);\n+ assert_insert_impl::<EnumU8AndU64>(34);\n+ assert_insert_impl::<EnumQuadSlotSize>(35);\n+ assert_insert_impl::<EnumLargerThanQuadSlot>(36);\n+ assert_insert_impl::<(u8, u32)>(37);\n+ }\n+\n+ #[storage(read, write)]\n+ fn assert_insert_index_out_of_bounds() {\n+ let vec: StorageKey<StorageVec<u64>> = StorageKey::new(b256::zero(), 0, b256::zero());\n+ vec.insert(1, 42);\n+ }\n+\n+ #[storage(write)]\n+ fn assert_insert_nested_storage_type() {\n+ let vec: StorageKey<StorageVec<StorageVec<u64>>> = StorageKey::new(b256::zero(), 0, b256::zero());\n+ vec.insert(0, StorageVec {}); // Nested storage types cannot be inserted.\n+ }\n+\n+}\n+\n+#[test]\n+fn insert() {\n+ let caller = abi(StorageVecInsertContractTestsAbi, CONTRACT_ID);\n+ caller.assert_insert();\n+}\n+\n+#[test(should_revert)]\n+fn insert_out_of_bounds() {\n+ let caller = abi(StorageVecInsertContractTestsAbi, CONTRACT_ID);\n+ caller.assert_insert_index_out_of_bounds();\n+}\n+\n+#[test(should_revert)]\n+fn insert_nested_storage_type() {\n+ let caller = abi(StorageVecInsertContractTestsAbi, CONTRACT_ID);\n+ caller.assert_insert_nested_storage_type();\n+}\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_iter_contract_tests/Forc.toml b/test/src/in_language_tests/test_programs/storage_vec_iter_contract_tests/Forc.toml\nnew file mode 100644\nindex 00000000000..73569e2ad3d\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_vec_iter_contract_tests/Forc.toml\n@@ -0,0 +1,9 @@\n+[project]\n+authors = [\"Fuel Labs <contact@fuel.sh>\"]\n+entry = \"main.sw\"\n+license = \"Apache-2.0\"\n+name = \"storage_vec_iter_contract_tests\"\n+\n+[dependencies]\n+std = { path = \"../../../../../sway-lib-std\" }\n+test_types = { path = \"../test_types\" }\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_iter_contract_tests/src/main.sw b/test/src/in_language_tests/test_programs/storage_vec_iter_contract_tests/src/main.sw\nnew file mode 100644\nindex 00000000000..f67f2a3024e\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_vec_iter_contract_tests/src/main.sw\n@@ -0,0 +1,315 @@\n+// TODO: The initial reason for having several `storage_vec` tests is\n+// reaching the limit in the data section size of a single contract\n+// that contained all the tests for `StorageVec<T>` methods.\n+// See: https://github.com/FuelLabs/sway/issues/7612\n+// But even when the issue is solved, it perhaps still makes sense to have\n+// separate test projects for better organization and readability\n+// of the tests.\n+// TODO: Replace `assert(x == y)` back with `assert_eq(x, y)` once `assert_eq` no longer\n+// causes data-section explosion. See also: https://github.com/FuelLabs/sway/issues/7612\n+contract;\n+\n+use test_types::*;\n+\n+use std::hash::{Hash, sha256};\n+use std::storage::storage_vec::*;\n+\n+storage {\n+ vec: StorageVec<u64> = StorageVec {},\n+ vec_of_vec: StorageVec<StorageVec<u64>> = StorageVec {},\n+}\n+\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+#[storage(read)]\n+fn assert_empty_vec_next_returns_none_impl<T>(slot_id_preimage: u64) {\n+ let vec: StorageKey<StorageVec<T>> = StorageKey::new(sha256(slot_id_preimage), 0, sha256(slot_id_preimage + 100));\n+ assert(vec.iter().next().is_none());\n+}\n+\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+#[storage(read, write)]\n+fn assert_vec_with_elements_next_returns_element_impl<T>(\n+ slot_id_preimage: u64,\n+)\n+where\n+ T: Eq + TestInstance + AbiEncode,\n+{\n+ let vec: StorageKey<StorageVec<T>> = StorageKey::new(sha256(slot_id_preimage), 0, sha256(slot_id_preimage + 100));\n+\n+ const NUM_OF_ELEMENTS: u64 = 37;\n+ let expected_values = T::instances(NUM_OF_ELEMENTS);\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ vec.push(expected_values.get(i).unwrap());\n+ i += 1;\n+ }\n+\n+ let mut i = 0;\n+ let mut iter = vec.iter();\n+ while i < NUM_OF_ELEMENTS {\n+ let element = iter.next();\n+ assert(element.is_some());\n+\n+ let value = element.unwrap().read();\n+ assert(value == vec.get(i).unwrap().read());\n+\n+ i += 1;\n+ }\n+\n+ let element_after_last = iter.next();\n+ assert(element_after_last.is_none());\n+ let element_after_last = iter.next();\n+ assert(element_after_last.is_none());\n+}\n+\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+#[storage(read, write)]\n+fn assert_vec_with_elements_for_loop_iteration_impl<T>(\n+ slot_id_preimage: u64,\n+)\n+where\n+ T: Eq + TestInstance + AbiEncode,\n+{\n+ let vec: StorageKey<StorageVec<T>> = StorageKey::new(sha256(slot_id_preimage), 0, sha256(slot_id_preimage + 100));\n+\n+ const NUM_OF_ELEMENTS: u64 = 37;\n+ let expected_values = T::instances(NUM_OF_ELEMENTS);\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ vec.push(expected_values.get(i).unwrap());\n+ i += 1;\n+ }\n+\n+ let mut i = 0;\n+ for element in vec.iter() {\n+ let value = element.read();\n+ assert(value == vec.get(i).unwrap().read());\n+\n+ i += 1;\n+ }\n+\n+ assert(vec.len() == i);\n+}\n+\n+impl Contract {\n+ // Note that zero-sized types like, e.g., `()`, `[u64;0]`, or `EmptyStruct`,\n+ // by definition of the storage access semantics, cannot be stored in\n+ // a `StorageVec<T>`. If the `T` is zero-sized it must be an another\n+ // nested storage type, e.g., `StorageVec<StorageMap<u64, b256>>`.\n+ // So, in all the tests below, we don't have zero-sized types.\n+\n+ #[storage(read)]\n+ fn assert_empty_vec_next_returns_none() {\n+ assert_empty_vec_next_returns_none_impl::<bool>(1);\n+ assert_empty_vec_next_returns_none_impl::<u8>(2);\n+ assert_empty_vec_next_returns_none_impl::<u16>(3);\n+ assert_empty_vec_next_returns_none_impl::<u32>(4);\n+ assert_empty_vec_next_returns_none_impl::<u64>(5);\n+ assert_empty_vec_next_returns_none_impl::<u256>(6);\n+ assert_empty_vec_next_returns_none_impl::<b256>(7);\n+ assert_empty_vec_next_returns_none_impl::<raw_slice>(8);\n+ assert_empty_vec_next_returns_none_impl::<str>(9);\n+ assert_empty_vec_next_returns_none_impl::<str[2]>(10);\n+ assert_empty_vec_next_returns_none_impl::<str[5]>(11);\n+ assert_empty_vec_next_returns_none_impl::<str[6]>(12);\n+ assert_empty_vec_next_returns_none_impl::<str[8]>(13);\n+ assert_empty_vec_next_returns_none_impl::<str[12]>(14);\n+ assert_empty_vec_next_returns_none_impl::<str[13]>(15);\n+ assert_empty_vec_next_returns_none_impl::<[u64; 2]>(16);\n+ assert_empty_vec_next_returns_none_impl::<ArrayU8Len2>(17);\n+ assert_empty_vec_next_returns_none_impl::<ArrayU8Len5>(18);\n+ assert_empty_vec_next_returns_none_impl::<ArrayU8Len6>(19);\n+ assert_empty_vec_next_returns_none_impl::<ArrayU8Len8>(20);\n+ assert_empty_vec_next_returns_none_impl::<ArrayU8Len12>(21);\n+ assert_empty_vec_next_returns_none_impl::<ArrayU8Len13>(22);\n+ assert_empty_vec_next_returns_none_impl::<ArrayU64Len3>(23);\n+ assert_empty_vec_next_returns_none_impl::<ArrayNestedArrayU8Len2Len3>(24);\n+ assert_empty_vec_next_returns_none_impl::<ArrayStructBLen2>(25);\n+ assert_empty_vec_next_returns_none_impl::<RawPtrNewtype>(26);\n+ assert_empty_vec_next_returns_none_impl::<StructA>(27);\n+ assert_empty_vec_next_returns_none_impl::<StructB>(28);\n+ assert_empty_vec_next_returns_none_impl::<EnumSingleU8>(29);\n+ assert_empty_vec_next_returns_none_impl::<EnumSingleU64>(30);\n+ assert_empty_vec_next_returns_none_impl::<EnumSingleBool>(31);\n+ assert_empty_vec_next_returns_none_impl::<EnumMultiUnits>(32);\n+ assert_empty_vec_next_returns_none_impl::<EnumMultiOneByte>(33);\n+ assert_empty_vec_next_returns_none_impl::<EnumU8AndU64>(34);\n+ assert_empty_vec_next_returns_none_impl::<EnumQuadSlotSize>(35);\n+ assert_empty_vec_next_returns_none_impl::<EnumLargerThanQuadSlot>(36);\n+ assert_empty_vec_next_returns_none_impl::<(u8, u32)>(37);\n+ }\n+\n+ #[storage(read, write)]\n+ fn assert_vec_with_elements_next_returns_element() {\n+ assert_vec_with_elements_next_returns_element_impl::<bool>(1);\n+ assert_vec_with_elements_next_returns_element_impl::<u8>(2);\n+ assert_vec_with_elements_next_returns_element_impl::<u16>(3);\n+ assert_vec_with_elements_next_returns_element_impl::<u32>(4);\n+ assert_vec_with_elements_next_returns_element_impl::<u64>(5);\n+ assert_vec_with_elements_next_returns_element_impl::<u256>(6);\n+ assert_vec_with_elements_next_returns_element_impl::<b256>(7);\n+ assert_vec_with_elements_next_returns_element_impl::<raw_slice>(8);\n+ assert_vec_with_elements_next_returns_element_impl::<str>(9);\n+ assert_vec_with_elements_next_returns_element_impl::<str[2]>(10);\n+ assert_vec_with_elements_next_returns_element_impl::<str[5]>(11);\n+ assert_vec_with_elements_next_returns_element_impl::<str[6]>(12);\n+ assert_vec_with_elements_next_returns_element_impl::<str[8]>(13);\n+ assert_vec_with_elements_next_returns_element_impl::<str[12]>(14);\n+ assert_vec_with_elements_next_returns_element_impl::<str[13]>(15);\n+ assert_vec_with_elements_next_returns_element_impl::<[u64; 2]>(16);\n+ assert_vec_with_elements_next_returns_element_impl::<ArrayU8Len2>(17);\n+ assert_vec_with_elements_next_returns_element_impl::<ArrayU8Len5>(18);\n+ assert_vec_with_elements_next_returns_element_impl::<ArrayU8Len6>(19);\n+ assert_vec_with_elements_next_returns_element_impl::<ArrayU8Len8>(20);\n+ assert_vec_with_elements_next_returns_element_impl::<ArrayU8Len12>(21);\n+ assert_vec_with_elements_next_returns_element_impl::<ArrayU8Len13>(22);\n+ assert_vec_with_elements_next_returns_element_impl::<ArrayU64Len3>(23);\n+ assert_vec_with_elements_next_returns_element_impl::<ArrayNestedArrayU8Len2Len3>(24);\n+ assert_vec_with_elements_next_returns_element_impl::<ArrayStructBLen2>(25);\n+ assert_vec_with_elements_next_returns_element_impl::<RawPtrNewtype>(26);\n+ assert_vec_with_elements_next_returns_element_impl::<StructA>(27);\n+ assert_vec_with_elements_next_returns_element_impl::<StructB>(28);\n+ assert_vec_with_elements_next_returns_element_impl::<EnumSingleU8>(29);\n+ assert_vec_with_elements_next_returns_element_impl::<EnumSingleU64>(30);\n+ assert_vec_with_elements_next_returns_element_impl::<EnumSingleBool>(31);\n+ assert_vec_with_elements_next_returns_element_impl::<EnumMultiUnits>(32);\n+ assert_vec_with_elements_next_returns_element_impl::<EnumMultiOneByte>(33);\n+ assert_vec_with_elements_next_returns_element_impl::<EnumU8AndU64>(34);\n+ assert_vec_with_elements_next_returns_element_impl::<EnumQuadSlotSize>(35);\n+ assert_vec_with_elements_next_returns_element_impl::<EnumLargerThanQuadSlot>(36);\n+ assert_vec_with_elements_next_returns_element_impl::<(u8, u32)>(37);\n+ }\n+\n+ #[storage(read, write)]\n+ fn assert_vec_with_elements_for_loop_iteration() {\n+ assert_vec_with_elements_for_loop_iteration_impl::<bool>(1);\n+ assert_vec_with_elements_for_loop_iteration_impl::<u8>(2);\n+ assert_vec_with_elements_for_loop_iteration_impl::<u16>(3);\n+ assert_vec_with_elements_for_loop_iteration_impl::<u32>(4);\n+ assert_vec_with_elements_for_loop_iteration_impl::<u64>(5);\n+ assert_vec_with_elements_for_loop_iteration_impl::<u256>(6);\n+ assert_vec_with_elements_for_loop_iteration_impl::<b256>(7);\n+ assert_vec_with_elements_for_loop_iteration_impl::<raw_slice>(8);\n+ assert_vec_with_elements_for_loop_iteration_impl::<str>(9);\n+ assert_vec_with_elements_for_loop_iteration_impl::<str[2]>(10);\n+ assert_vec_with_elements_for_loop_iteration_impl::<str[5]>(11);\n+ assert_vec_with_elements_for_loop_iteration_impl::<str[6]>(12);\n+ assert_vec_with_elements_for_loop_iteration_impl::<str[8]>(13);\n+ assert_vec_with_elements_for_loop_iteration_impl::<str[12]>(14);\n+ assert_vec_with_elements_for_loop_iteration_impl::<str[13]>(15);\n+ assert_vec_with_elements_for_loop_iteration_impl::<[u64; 2]>(16);\n+ assert_vec_with_elements_for_loop_iteration_impl::<ArrayU8Len2>(17);\n+ assert_vec_with_elements_for_loop_iteration_impl::<ArrayU8Len5>(18);\n+ assert_vec_with_elements_for_loop_iteration_impl::<ArrayU8Len6>(19);\n+ assert_vec_with_elements_for_loop_iteration_impl::<ArrayU8Len8>(20);\n+ assert_vec_with_elements_for_loop_iteration_impl::<ArrayU8Len12>(21);\n+ assert_vec_with_elements_for_loop_iteration_impl::<ArrayU8Len13>(22);\n+ assert_vec_with_elements_for_loop_iteration_impl::<ArrayU64Len3>(23);\n+ assert_vec_with_elements_for_loop_iteration_impl::<ArrayNestedArrayU8Len2Len3>(24);\n+ assert_vec_with_elements_for_loop_iteration_impl::<ArrayStructBLen2>(25);\n+ assert_vec_with_elements_for_loop_iteration_impl::<RawPtrNewtype>(26);\n+ assert_vec_with_elements_for_loop_iteration_impl::<StructA>(27);\n+ assert_vec_with_elements_for_loop_iteration_impl::<StructB>(28);\n+ assert_vec_with_elements_for_loop_iteration_impl::<EnumSingleU8>(29);\n+ assert_vec_with_elements_for_loop_iteration_impl::<EnumSingleU64>(30);\n+ assert_vec_with_elements_for_loop_iteration_impl::<EnumSingleBool>(31);\n+ assert_vec_with_elements_for_loop_iteration_impl::<EnumMultiUnits>(32);\n+ assert_vec_with_elements_for_loop_iteration_impl::<EnumMultiOneByte>(33);\n+ assert_vec_with_elements_for_loop_iteration_impl::<EnumU8AndU64>(34);\n+ assert_vec_with_elements_for_loop_iteration_impl::<EnumQuadSlotSize>(35);\n+ assert_vec_with_elements_for_loop_iteration_impl::<EnumLargerThanQuadSlot>(36);\n+ assert_vec_with_elements_for_loop_iteration_impl::<(u8, u32)>(37);\n+ }\n+\n+ #[storage(read, write)]\n+ fn storage_vec_field_for_loop_iteration() {\n+ const NUM_OF_ELEMENTS: u64 = 37;\n+ let expected_values = u64::instances(NUM_OF_ELEMENTS);\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ storage.vec.push(expected_values.get(i).unwrap());\n+ i += 1;\n+ }\n+\n+ let mut i = 0;\n+ for element in storage.vec.iter() {\n+ let value = element.read();\n+ assert(value == storage.vec.get(i).unwrap().read());\n+\n+ i += 1;\n+ }\n+\n+ assert(storage.vec.len() == i);\n+ }\n+\n+ #[storage(read, write)]\n+ fn storage_vec_field_nested_for_loop_iteration() {\n+ const NUM_OF_NESTED_VECTORS: u64 = 7;\n+ const NUM_OF_ELEMENTS: u64 = 37;\n+ let expected_values = u64::instances(NUM_OF_ELEMENTS);\n+\n+ let mut i = 0;\n+ while i < NUM_OF_NESTED_VECTORS {\n+ let nested_vector = StorageVec::<u64> {};\n+ storage.vec_of_vec.push(nested_vector);\n+\n+ let nested_vector = storage.vec_of_vec.get(i).unwrap();\n+\n+ let mut j = 0;\n+ while j < NUM_OF_ELEMENTS {\n+ nested_vector.push(expected_values.get(j).unwrap());\n+ j += 1;\n+ }\n+\n+ i += 1;\n+ }\n+\n+ let mut i = 0;\n+ for nested_vec in storage.vec_of_vec.iter() {\n+ let mut j = 0;\n+ for element in nested_vec.iter() {\n+ let value = element.read();\n+ let stored_value = storage.vec_of_vec.get(i).unwrap().get(j).unwrap().read();\n+ assert(value == stored_value);\n+\n+ j += 1;\n+ }\n+\n+ assert(nested_vec.len() == j);\n+\n+ i += 1;\n+ }\n+\n+ assert(storage.vec_of_vec.len() == i);\n+ }\n+}\n+\n+#[test]\n+fn empty_vec_next_returns_none() {\n+ let contract_abi = abi(StorageVecIterContractTestsAbi, CONTRACT_ID);\n+ contract_abi.assert_empty_vec_next_returns_none();\n+}\n+\n+#[test]\n+fn vec_with_elements_next_returns_element() {\n+ let contract_abi = abi(StorageVecIterContractTestsAbi, CONTRACT_ID);\n+ contract_abi.assert_vec_with_elements_next_returns_element();\n+}\n+\n+#[test]\n+fn vec_with_elements_for_loop_iteration() {\n+ let contract_abi = abi(StorageVecIterContractTestsAbi, CONTRACT_ID);\n+ contract_abi.assert_vec_with_elements_for_loop_iteration();\n+}\n+\n+#[test]\n+fn storage_vec_field_for_loop_iteration() {\n+ let contract_abi = abi(StorageVecIterContractTestsAbi, CONTRACT_ID);\n+ contract_abi.storage_vec_field_for_loop_iteration();\n+}\n+\n+#[test]\n+fn storage_vec_field_nested_for_loop_iteration() {\n+ let contract_abi = abi(StorageVecIterContractTestsAbi, CONTRACT_ID);\n+ contract_abi.storage_vec_field_nested_for_loop_iteration();\n+}\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_iter_tests/src/impls.sw b/test/src/in_language_tests/test_programs/storage_vec_iter_tests/src/impls.sw\ndeleted file mode 100644\nindex f217355e8aa..00000000000\n--- a/test/src/in_language_tests/test_programs/storage_vec_iter_tests/src/impls.sw\n+++ /dev/null\n@@ -1,347 +0,0 @@\n-library;\n-\n-use std::ops::Eq;\n-use std::flags::{disable_panic_on_overflow, enable_panic_on_overflow};\n-use std::raw_slice::*;\n-\n-pub trait TestInstance {\n- /// Returns a [Vec] of `len` quasi-random elements\n- /// of the type for which the trait is implemented.\n- fn elements(len: u64) -> Vec<Self>;\n-}\n-\n-impl TestInstance for bool {\n- fn elements(len: u64) -> Vec<Self> {\n- let mut res = Vec::new();\n- let mut i = 0;\n- while i < len {\n- res.push(i % 3 == 0);\n- i += 1;\n- }\n- res\n- }\n-}\n-\n-impl TestInstance for u8 {\n- fn elements(len: u64) -> Vec<Self> {\n- let mut res = Vec::new();\n- res.push(1);\n- res.push(2);\n- let mut i = 2;\n- let _ = disable_panic_on_overflow();\n- while i < len {\n- res.push(res.get(i - 1).unwrap() + res.get(i - 2).unwrap());\n- i += 1;\n- }\n- enable_panic_on_overflow();\n- res\n- }\n-}\n-\n-impl TestInstance for u16 {\n- fn elements(len: u64) -> Vec<Self> {\n- let mut res = Vec::new();\n- res.push(1);\n- res.push(2);\n- let mut i = 2;\n- let _ = disable_panic_on_overflow();\n- while i < len {\n- res.push(res.get(i - 1).unwrap() + res.get(i - 2).unwrap());\n- i += 1;\n- }\n- enable_panic_on_overflow();\n- res\n- }\n-}\n-\n-impl TestInstance for u32 {\n- fn elements(len: u64) -> Vec<Self> {\n- let mut res = Vec::new();\n- res.push(1);\n- res.push(2);\n- let mut i = 2;\n- let _ = disable_panic_on_overflow();\n- while i < len {\n- res.push(res.get(i - 1).unwrap() + res.get(i - 2).unwrap());\n- i += 1;\n- }\n- enable_panic_on_overflow();\n- res\n- }\n-}\n-\n-impl TestInstance for u64 {\n- fn elements(len: u64) -> Vec<Self> {\n- let mut res = Vec::new();\n- res.push(1);\n- res.push(2);\n- let mut i = 2;\n- let _ = disable_panic_on_overflow();\n- while i < len {\n- res.push(res.get(i - 1).unwrap() + res.get(i - 2).unwrap());\n- i += 1;\n- }\n- enable_panic_on_overflow();\n- res\n- }\n-}\n-\n-impl TestInstance for u256 {\n- fn elements(len: u64) -> Vec<Self> {\n- let mut res = Vec::new();\n- res.push(0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20u256);\n- let mut i = 1;\n- while i < len {\n- res.push(res.get(i - 1).unwrap() / i.into());\n- i += 1;\n- }\n- res\n- }\n-}\n-\n-impl TestInstance for str {\n- fn elements(len: u64) -> Vec<Self> {\n- let mut res = Vec::new();\n- let mut i = 0;\n- while i < len {\n- let string: str = match i % 3 {\n- 0 => \"a1\",\n- 1 => \"b2c3\",\n- 2 => \"d4e5f6\",\n- _ => \"unreachable\",\n- };\n- res.push(string);\n- i += 1;\n- }\n- res\n- }\n-}\n-\n-impl TestInstance for str[6] {\n- fn elements(len: u64) -> Vec<Self> {\n- let mut res = Vec::new();\n- let mut i = 0;\n- while i < len {\n- let string: str[6] = match i % 3 {\n- 0 => __to_str_array(\"a1a1a1\"),\n- 1 => __to_str_array(\"b2c3b2\"),\n- 2 => __to_str_array(\"d4e5f6\"),\n- _ => __to_str_array(\"......\"),\n- };\n- res.push(string);\n- i += 1;\n- }\n- res\n- }\n-}\n-\n-impl TestInstance for [u64; 2] {\n- fn elements(len: u64) -> Vec<Self> {\n- let mut res = Vec::new();\n- res.push([1, 1]);\n- res.push([2, 2]);\n- let mut i = 2;\n- let _ = disable_panic_on_overflow();\n- while i < len {\n- let val = res.get(i - 1).unwrap()[0] + res.get(i - 2).unwrap()[0];\n- res.push([val, val]);\n- i += 1;\n- }\n- enable_panic_on_overflow();\n- res\n- }\n-}\n-\n-pub struct Struct {\n- x: u64,\n-}\n-\n-impl PartialEq for Struct {\n- fn eq(self, other: Self) -> bool {\n- self.x == other.x\n- }\n-}\n-impl Eq for Struct {}\n-\n-impl TestInstance for Struct {\n- fn elements(len: u64) -> Vec<Self> {\n- let values = u64::elements(len);\n- let mut res = Vec::new();\n- let mut i = 0;\n- while i < len {\n- res.push(Struct {\n- x: values.get(i).unwrap(),\n- });\n- i += 1;\n- }\n- res\n- }\n-}\n-\n-pub struct EmptyStruct {}\n-\n-impl PartialEq for EmptyStruct {\n- fn eq(self, other: Self) -> bool {\n- true\n- }\n-}\n-impl Eq for EmptyStruct {}\n-\n-impl TestInstance for EmptyStruct {\n- fn elements(len: u64) -> Vec<Self> {\n- let mut res = Vec::new();\n- let mut i = 0;\n- while i < len {\n- res.push(EmptyStruct {});\n- i += 1;\n- }\n- res\n- }\n-}\n-\n-pub enum Enum {\n- A: u64,\n-}\n-\n-impl PartialEq for Enum {\n- fn eq(self, other: Self) -> bool {\n- match (self, other) {\n- (Enum::A(l), Enum::A(r)) => l == r,\n- }\n- }\n-}\n-impl Eq for Enum {}\n-\n-impl TestInstance for Enum {\n- fn elements(len: u64) -> Vec<Self> {\n- let values = u64::elements(len);\n- let mut res = Vec::new();\n- let mut i = 0;\n- while i < len {\n- res.push(Enum::A(values.get(i).unwrap()));\n- i += 1;\n- }\n- res\n- }\n-}\n-\n-impl TestInstance for (u8, u32) {\n- fn elements(len: u64) -> Vec<Self> {\n- let u8_values = u8::elements(len);\n- let u32_values = u32::elements(len);\n- let mut res = Vec::new();\n- let mut i = 0;\n- while i < len {\n- res.push((u8_values.get(i).unwrap(), u32_values.get(i).unwrap()));\n- i += 1;\n- }\n- res\n- }\n-}\n-\n-impl TestInstance for b256 {\n- fn elements(len: u64) -> Vec<Self> {\n- let mut res = Vec::new();\n- res.push(\n- 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20u256\n- .as_b256(),\n- );\n- let mut i = 1;\n- while i < len {\n- res.push((res.get(i - 1).unwrap().as_u256() / i.into()).as_b256());\n- i += 1;\n- }\n- res\n- }\n-}\n-\n-pub struct RawPtrNewtype {\n- ptr: raw_ptr,\n-}\n-\n-impl TestInstance for RawPtrNewtype {\n- fn elements(len: u64) -> Vec<Self> {\n- let values = u8::elements(len);\n- let mut res = Vec::new();\n- let mut i = 0;\n- while i < len {\n- let null_ptr = asm() {\n- zero: raw_ptr\n- };\n- res.push(RawPtrNewtype {\n- ptr: null_ptr.add::<u64>(values.get(i).unwrap().as_u64())\n- });\n- i += 1;\n- }\n- res\n- }\n-}\n-\n-impl AbiEncode for RawPtrNewtype {\n- fn is_encode_trivial() -> bool { false }\n- fn abi_encode(self, buffer: Buffer) -> Buffer {\n- let ptr_as_u64 = asm(p: self.ptr) {\n- p: u64\n- };\n- ptr_as_u64.abi_encode(buffer)\n- }\n-}\n-\n-impl PartialEq for RawPtrNewtype {\n- fn eq(self, other: Self) -> bool {\n- self.ptr == other.ptr\n- }\n-}\n-impl Eq for RawPtrNewtype {}\n-\n-impl TestInstance for raw_slice {\n- fn elements(len: u64) -> Vec<Self> {\n- let raw_ptr_values = RawPtrNewtype::elements(len);\n- let mut ptr_values = Vec::<raw_ptr>::new();\n- for raw_ptr in raw_ptr_values.iter() {\n- ptr_values.push(raw_ptr.ptr);\n- }\n-\n- let len_values = u8::elements(len);\n- let mut res = Vec::new();\n- let mut i = 0;\n- while i < len {\n- res.push(raw_slice::from_parts::<u64>(\n- ptr_values\n- .get(i)\n- .unwrap(),\n- len_values\n- .get(i)\n- .unwrap()\n- .as_u64(),\n- ));\n- i += 1;\n- }\n- res\n- }\n-}\n-\n-impl TestInstance for () {\n- fn elements(len: u64) -> Vec<Self> {\n- let mut res = Vec::new();\n- let mut i = 0;\n- while i < len {\n- res.push(());\n- i += 1;\n- }\n- res\n- }\n-}\n-\n-impl TestInstance for [u64; 0] {\n- fn elements(len: u64) -> Vec<Self> {\n- let mut res = Vec::new();\n- let mut i = 0;\n- while i < len {\n- res.push([]);\n- i += 1;\n- }\n- res\n- }\n-}\n-\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_iter_tests/src/main.sw b/test/src/in_language_tests/test_programs/storage_vec_iter_tests/src/main.sw\ndeleted file mode 100644\nindex f5e28c2f330..00000000000\n--- a/test/src/in_language_tests/test_programs/storage_vec_iter_tests/src/main.sw\n+++ /dev/null\n@@ -1,253 +0,0 @@\n-contract;\n-\n-mod impls;\n-\n-use impls::*;\n-use impls::Enum;\n-\n-use std::hash::{Hash, sha256};\n-use std::storage::storage_vec::*;\n-\n-#[cfg(experimental_dynamic_storage = false)]\n-storage {\n- vec: StorageVec<u64> = StorageVec {},\n- vec_of_vec: StorageVec<StorageVec<u64>> = StorageVec {},\n-}\n-\n-#[cfg(experimental_dynamic_storage = false)]\n-#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n-#[storage(read)]\n-fn assert_empty_vec_next_returns_none_impl<T>(slot_id_preimage: u64) {\n- let vec: StorageKey<StorageVec<T>> = StorageKey::new(sha256(slot_id_preimage), 0, sha256(slot_id_preimage + 100));\n- assert(vec.iter().next().is_none());\n-}\n-\n-#[cfg(experimental_dynamic_storage = false)]\n-#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n-#[storage(read, write)]\n-fn assert_vec_with_elements_next_returns_element_impl<T>(\n- slot_id_preimage: u64,\n-)\n-where\n- T: Eq + TestInstance + AbiEncode,\n-{\n- let vec: StorageKey<StorageVec<T>> = StorageKey::new(sha256(slot_id_preimage), 0, sha256(slot_id_preimage + 100));\n-\n- const NUM_OF_ELEMENTS: u64 = 37;\n- let expected_values = T::elements(NUM_OF_ELEMENTS);\n- let mut i = 0;\n- while i < NUM_OF_ELEMENTS {\n- vec.push(expected_values.get(i).unwrap());\n- i += 1;\n- }\n-\n- let mut i = 0;\n- let mut iter = vec.iter();\n- while i < NUM_OF_ELEMENTS {\n- let element = iter.next();\n- assert(element.is_some());\n-\n- let value = element.unwrap().read();\n- assert_eq(value, vec.get(i).unwrap().read());\n-\n- i += 1;\n- }\n-\n- let element_after_last = iter.next();\n- assert(element_after_last.is_none());\n- let element_after_last = iter.next();\n- assert(element_after_last.is_none());\n-}\n-\n-#[cfg(experimental_dynamic_storage = false)]\n-#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n-#[storage(read, write)]\n-fn assert_vec_with_elements_for_loop_iteration_impl<T>(\n- slot_id_preimage: u64,\n-)\n-where\n- T: Eq + TestInstance + AbiEncode,\n-{\n- let vec: StorageKey<StorageVec<T>> = StorageKey::new(sha256(slot_id_preimage), 0, sha256(slot_id_preimage + 100));\n-\n- const NUM_OF_ELEMENTS: u64 = 37;\n- let expected_values = T::elements(NUM_OF_ELEMENTS);\n- let mut i = 0;\n- while i < NUM_OF_ELEMENTS {\n- vec.push(expected_values.get(i).unwrap());\n- i += 1;\n- }\n-\n- let mut i = 0;\n- for element in vec.iter() {\n- let value = element.read();\n- assert_eq(value, vec.get(i).unwrap().read());\n-\n- i += 1;\n- }\n-\n- assert_eq(vec.len(), i);\n-}\n-\n-#[cfg(experimental_dynamic_storage = false)]\n-impl Contract {\n- // Note that zero-sized types like, e.g., `()`, `[u64;0]`, or `EmptyStruct`,\n- // by definition of the storage access semantics, cannot be stored in\n- // a `StorageVec<T>`. If the `T` is zero-sized it must be an another\n- // nested storage type, e.g., `StorageVec<StorageMap<u64, b256>>`.\n- // So, in all the tests below, we don't have zero-sized types.\n-\n- #[storage(read)]\n- fn assert_empty_vec_next_returns_none() {\n- assert_empty_vec_next_returns_none_impl::<bool>(2);\n- assert_empty_vec_next_returns_none_impl::<u8>(3);\n- assert_empty_vec_next_returns_none_impl::<u16>(4);\n- assert_empty_vec_next_returns_none_impl::<u32>(5);\n- assert_empty_vec_next_returns_none_impl::<u64>(6);\n- assert_empty_vec_next_returns_none_impl::<u256>(7);\n- assert_empty_vec_next_returns_none_impl::<[u64; 2]>(8);\n- assert_empty_vec_next_returns_none_impl::<Struct>(10);\n- assert_empty_vec_next_returns_none_impl::<str>(12);\n- assert_empty_vec_next_returns_none_impl::<str[6]>(13);\n- assert_empty_vec_next_returns_none_impl::<Enum>(14);\n- assert_empty_vec_next_returns_none_impl::<(u8, u32)>(15);\n- assert_empty_vec_next_returns_none_impl::<b256>(16);\n- assert_empty_vec_next_returns_none_impl::<RawPtrNewtype>(17);\n- assert_empty_vec_next_returns_none_impl::<raw_slice>(18);\n- }\n-\n- #[storage(read, write)]\n- fn assert_vec_with_elements_next_returns_element() {\n- assert_vec_with_elements_next_returns_element_impl::<bool>(2);\n- assert_vec_with_elements_next_returns_element_impl::<u8>(3);\n- assert_vec_with_elements_next_returns_element_impl::<u16>(4);\n- assert_vec_with_elements_next_returns_element_impl::<u32>(5);\n- assert_vec_with_elements_next_returns_element_impl::<u64>(6);\n- assert_vec_with_elements_next_returns_element_impl::<u256>(7);\n- assert_vec_with_elements_next_returns_element_impl::<[u64; 2]>(8);\n- assert_vec_with_elements_next_returns_element_impl::<Struct>(10);\n- assert_vec_with_elements_next_returns_element_impl::<str>(12);\n- assert_vec_with_elements_next_returns_element_impl::<str[6]>(13);\n- assert_vec_with_elements_next_returns_element_impl::<Enum>(14);\n- assert_vec_with_elements_next_returns_element_impl::<(u8, u32)>(15);\n- assert_vec_with_elements_next_returns_element_impl::<b256>(16);\n- assert_vec_with_elements_next_returns_element_impl::<RawPtrNewtype>(17);\n- assert_vec_with_elements_next_returns_element_impl::<raw_slice>(18);\n- }\n-\n- #[storage(read, write)]\n- fn assert_vec_with_elements_for_loop_iteration() {\n- assert_vec_with_elements_for_loop_iteration_impl::<bool>(2);\n- assert_vec_with_elements_for_loop_iteration_impl::<u8>(3);\n- assert_vec_with_elements_for_loop_iteration_impl::<u16>(4);\n- assert_vec_with_elements_for_loop_iteration_impl::<u32>(5);\n- assert_vec_with_elements_for_loop_iteration_impl::<u64>(6);\n- assert_vec_with_elements_for_loop_iteration_impl::<u256>(7);\n- assert_vec_with_elements_for_loop_iteration_impl::<[u64; 2]>(8);\n- assert_vec_with_elements_for_loop_iteration_impl::<Struct>(10);\n- assert_vec_with_elements_for_loop_iteration_impl::<str>(12);\n- assert_vec_with_elements_for_loop_iteration_impl::<str[6]>(13);\n- assert_vec_with_elements_for_loop_iteration_impl::<Enum>(14);\n- assert_vec_with_elements_for_loop_iteration_impl::<(u8, u32)>(15);\n- assert_vec_with_elements_for_loop_iteration_impl::<b256>(16);\n- assert_vec_with_elements_for_loop_iteration_impl::<RawPtrNewtype>(17);\n- assert_vec_with_elements_for_loop_iteration_impl::<raw_slice>(18);\n- }\n-\n- #[storage(read, write)]\n- fn storage_vec_field_for_loop_iteration() {\n- const NUM_OF_ELEMENTS: u64 = 37;\n- let expected_values = u64::elements(NUM_OF_ELEMENTS);\n- let mut i = 0;\n- while i < NUM_OF_ELEMENTS {\n- storage.vec.push(expected_values.get(i).unwrap());\n- i += 1;\n- }\n-\n- let mut i = 0;\n- for element in storage.vec.iter() {\n- let value = element.read();\n- assert_eq(value, storage.vec.get(i).unwrap().read());\n-\n- i += 1;\n- }\n-\n- assert_eq(storage.vec.len(), i);\n- }\n-\n- #[storage(read, write)]\n- fn storage_vec_field_nested_for_loop_iteration() {\n- const NUM_OF_NESTED_VECTORS: u64 = 7;\n- const NUM_OF_ELEMENTS: u64 = 37;\n- let expected_values = u64::elements(NUM_OF_ELEMENTS);\n-\n- let mut i = 0;\n- while i < NUM_OF_NESTED_VECTORS {\n- let nested_vector = StorageVec::<u64> {};\n- storage.vec_of_vec.push(nested_vector);\n-\n- let nested_vector = storage.vec_of_vec.get(i).unwrap();\n-\n- let mut j = 0;\n- while j < NUM_OF_ELEMENTS {\n- nested_vector.push(expected_values.get(j).unwrap());\n- j += 1;\n- }\n-\n- i += 1;\n- }\n-\n- let mut i = 0;\n- for nested_vec in storage.vec_of_vec.iter() {\n- let mut j = 0;\n- for element in nested_vec.iter() {\n- let value = element.read();\n- let stored_value = storage.vec_of_vec.get(i).unwrap().get(j).unwrap().read();\n- assert_eq(value, stored_value);\n-\n- j += 1;\n- }\n-\n- assert_eq(nested_vec.len(), j);\n-\n- i += 1;\n- }\n-\n- assert_eq(storage.vec_of_vec.len(), i);\n- }\n-}\n-\n-#[cfg(experimental_dynamic_storage = false)]\n-#[test]\n-fn empty_vec_next_returns_none() {\n- let contract_abi = abi(StorageVecIterTestsAbi, CONTRACT_ID);\n- contract_abi.assert_empty_vec_next_returns_none();\n-}\n-\n-#[cfg(experimental_dynamic_storage = false)]\n-#[test]\n-fn vec_with_elements_next_returns_element() {\n- let contract_abi = abi(StorageVecIterTestsAbi, CONTRACT_ID);\n- contract_abi.assert_vec_with_elements_next_returns_element();\n-}\n-\n-#[cfg(experimental_dynamic_storage = false)]\n-#[test]\n-fn vec_with_elements_for_loop_iteration() {\n- let contract_abi = abi(StorageVecIterTestsAbi, CONTRACT_ID);\n- contract_abi.assert_vec_with_elements_for_loop_iteration();\n-}\n-\n-#[cfg(experimental_dynamic_storage = false)]\n-#[test]\n-fn storage_vec_field_for_loop_iteration() {\n- let contract_abi = abi(StorageVecIterTestsAbi, CONTRACT_ID);\n- contract_abi.storage_vec_field_for_loop_iteration();\n-}\n-\n-#[cfg(experimental_dynamic_storage = false)]\n-#[test]\n-fn storage_vec_field_nested_for_loop_iteration() {\n- let contract_abi = abi(StorageVecIterTestsAbi, CONTRACT_ID);\n- contract_abi.storage_vec_field_nested_for_loop_iteration();\n-}\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_load_vec_contract_tests/Forc.toml b/test/src/in_language_tests/test_programs/storage_vec_load_vec_contract_tests/Forc.toml\nnew file mode 100644\nindex 00000000000..363dec8516d\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_vec_load_vec_contract_tests/Forc.toml\n@@ -0,0 +1,9 @@\n+[project]\n+authors = [\"Fuel Labs <contact@fuel.sh>\"]\n+entry = \"main.sw\"\n+license = \"Apache-2.0\"\n+name = \"storage_vec_load_vec_contract_tests\"\n+\n+[dependencies]\n+std = { path = \"../../../../../sway-lib-std\" }\n+test_types = { path = \"../test_types\" }\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_load_vec_contract_tests/src/main.sw b/test/src/in_language_tests/test_programs/storage_vec_load_vec_contract_tests/src/main.sw\nnew file mode 100644\nindex 00000000000..febd2d5805e\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_vec_load_vec_contract_tests/src/main.sw\n@@ -0,0 +1,151 @@\n+// TODO: The initial reason for having several `storage_vec` tests is\n+// reaching the limit in the data section size of a single contract\n+// that contained all the tests for `StorageVec<T>` methods.\n+// See: https://github.com/FuelLabs/sway/issues/7612\n+// But even when the issue is solved, it perhaps still makes sense to have\n+// separate test projects for better organization and readability\n+// of the tests.\n+// TODO: Replace `assert(x == y)` back with `assert_eq(x, y)` once `assert_eq` no longer\n+// causes data-section explosion. See also: https://github.com/FuelLabs/sway/issues/7612\n+contract;\n+\n+use test_types::*;\n+\n+use std::hash::{Hash, sha256};\n+use std::storage::storage_vec::*;\n+\n+/// Default number of vector elements to use in tests.\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+const NUM_OF_ELEMENTS: u64 = 11;\n+\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+#[storage(read, write)]\n+fn assert_load_vec_impl<T>(\n+ slot_id_preimage: u64,\n+)\n+where\n+ T: Eq + TestInstance + AbiEncode,\n+{\n+ assert_non_zero_sized_type::<T>();\n+\n+ let vec: StorageKey<StorageVec<T>> = StorageKey::new(sha256(slot_id_preimage), 0, sha256(slot_id_preimage + 100));\n+\n+ let expected_values = T::instances(NUM_OF_ELEMENTS);\n+\n+ // Load from empty storage vector.\n+ let mut loaded_vec = vec.load_vec();\n+ assert(0 == loaded_vec.len());\n+\n+ // Load full vector content and verify order.\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ vec.push(expected_values.get(i).unwrap());\n+ i += 1;\n+ }\n+\n+ loaded_vec = vec.load_vec();\n+ assert(NUM_OF_ELEMENTS == loaded_vec.len());\n+\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ assert(expected_values.get(i) == loaded_vec.get(i));\n+ i += 1;\n+ }\n+\n+ // Load after replacing content with a shorter vector.\n+ let mut shorter_heap_vec = Vec::<T>::new();\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS / 2 {\n+ shorter_heap_vec.push(expected_values.get(i).unwrap());\n+ i += 1;\n+ }\n+\n+ vec.store_vec(shorter_heap_vec);\n+ loaded_vec = vec.load_vec();\n+ assert(NUM_OF_ELEMENTS / 2 == loaded_vec.len());\n+\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS / 2 {\n+ assert(expected_values.get(i) == loaded_vec.get(i));\n+ i += 1;\n+ }\n+\n+ // Load single-element vector.\n+ let _ = vec.clear();\n+ vec.push(expected_values.get(0).unwrap());\n+\n+ loaded_vec = vec.load_vec();\n+ assert(1 == loaded_vec.len());\n+ assert(expected_values.get(0) == loaded_vec.get(0));\n+}\n+\n+impl Contract {\n+ // Note that zero-sized types like, e.g., `()`, `[u64;0]`, or `EmptyStruct`,\n+ // by definition of the storage access semantics, cannot be stored in\n+ // a `StorageVec<T>`. If the `T` is zero-sized it must be an another\n+ // nested storage type, e.g., `StorageVec<StorageMap<u64, b256>>`.\n+ // So, in all the tests below, we don't have zero-sized types.\n+\n+ #[storage(read, write)]\n+ fn assert_load_vec() {\n+ assert_load_vec_impl::<bool>(1);\n+ assert_load_vec_impl::<u8>(2);\n+ assert_load_vec_impl::<u16>(3);\n+ assert_load_vec_impl::<u32>(4);\n+ assert_load_vec_impl::<u64>(5);\n+ assert_load_vec_impl::<u256>(6);\n+ assert_load_vec_impl::<b256>(7);\n+ assert_load_vec_impl::<raw_slice>(8);\n+ assert_load_vec_impl::<str>(9);\n+ assert_load_vec_impl::<str[2]>(10);\n+ assert_load_vec_impl::<str[5]>(11);\n+ assert_load_vec_impl::<str[6]>(12);\n+ assert_load_vec_impl::<str[8]>(13);\n+ assert_load_vec_impl::<str[12]>(14);\n+ assert_load_vec_impl::<str[13]>(15);\n+ assert_load_vec_impl::<[u64; 2]>(16);\n+ assert_load_vec_impl::<ArrayU8Len2>(17);\n+ assert_load_vec_impl::<ArrayU8Len5>(18);\n+ assert_load_vec_impl::<ArrayU8Len6>(19);\n+ assert_load_vec_impl::<ArrayU8Len8>(20);\n+ assert_load_vec_impl::<ArrayU8Len12>(21);\n+ assert_load_vec_impl::<ArrayU8Len13>(22);\n+ assert_load_vec_impl::<ArrayU64Len3>(23);\n+ assert_load_vec_impl::<ArrayNestedArrayU8Len2Len3>(24);\n+ assert_load_vec_impl::<ArrayStructBLen2>(25);\n+ assert_load_vec_impl::<RawPtrNewtype>(26);\n+ assert_load_vec_impl::<StructA>(27);\n+ assert_load_vec_impl::<StructB>(28);\n+ assert_load_vec_impl::<EnumSingleU8>(29);\n+ assert_load_vec_impl::<EnumSingleU64>(30);\n+ assert_load_vec_impl::<EnumSingleBool>(31);\n+ assert_load_vec_impl::<EnumMultiUnits>(32);\n+ assert_load_vec_impl::<EnumMultiOneByte>(33);\n+ assert_load_vec_impl::<EnumU8AndU64>(34);\n+ assert_load_vec_impl::<EnumQuadSlotSize>(35);\n+ assert_load_vec_impl::<EnumLargerThanQuadSlot>(36);\n+ assert_load_vec_impl::<(u8, u32)>(37);\n+ }\n+\n+ #[storage(read, write)]\n+ fn assert_load_vec_nested_storage_type() {\n+ let vec: StorageKey<StorageVec<StorageVec<u64>>> = StorageKey::new(b256::zero(), 0, b256::zero());\n+\n+ // Ensure non-empty vector so `load_vec` hits nested-type checks for both implementations.\n+ vec.resize(1, StorageVec {});\n+ let _ = vec.load_vec(); // Nested storage types cannot be loaded.\n+ }\n+\n+}\n+\n+#[test]\n+fn load_vec() {\n+ let caller = abi(StorageVecLoadVecContractTestsAbi, CONTRACT_ID);\n+ caller.assert_load_vec();\n+}\n+\n+#[test(should_revert)]\n+fn load_vec_nested_storage_type() {\n+ let caller = abi(StorageVecLoadVecContractTestsAbi, CONTRACT_ID);\n+ caller.assert_load_vec_nested_storage_type();\n+}\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_of_storage_vec_contract_tests/Forc.toml b/test/src/in_language_tests/test_programs/storage_vec_of_storage_vec_contract_tests/Forc.toml\nnew file mode 100644\nindex 00000000000..0516a30479d\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_vec_of_storage_vec_contract_tests/Forc.toml\n@@ -0,0 +1,9 @@\n+[project]\n+authors = [\"Fuel Labs <contact@fuel.sh>\"]\n+entry = \"main.sw\"\n+license = \"Apache-2.0\"\n+name = \"storage_vec_of_storage_vec_contract_tests\"\n+\n+[dependencies]\n+std = { path = \"../../../../../sway-lib-std\" }\n+test_types = { path = \"../test_types\" }\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_of_storage_vec_contract_tests/src/main.sw b/test/src/in_language_tests/test_programs/storage_vec_of_storage_vec_contract_tests/src/main.sw\nnew file mode 100644\nindex 00000000000..2c6d4d9e925\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_vec_of_storage_vec_contract_tests/src/main.sw\n@@ -0,0 +1,123 @@\n+// TODO: The initial reason for having several `storage_vec` tests is\n+// reaching the limit in the data section size of a single contract\n+// that contained all the tests for `StorageVec<T>` methods.\n+// See: https://github.com/FuelLabs/sway/issues/7612\n+// But even when the issue is solved, it perhaps still makes sense to have\n+// separate test projects for better organization and readability\n+// of the tests.\n+// TODO: Replace `assert(x == y)` back with `assert_eq(x, y)` once `assert_eq` no longer\n+// causes data-section explosion. See also: https://github.com/FuelLabs/sway/issues/7612\n+contract;\n+\n+use test_types::*;\n+\n+use std::hash::{Hash, sha256};\n+use std::storage::storage_vec::*;\n+\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+const NUM_OF_NESTED_VECTORS: u64 = 7;\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+const NUM_OF_ELEMENTS: u64 = 11;\n+\n+storage {\n+ //vec_of_vec: StorageVec<StorageVec<u64>> = StorageVec {},\n+}\n+\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+#[storage(read, write)]\n+fn assert_push_and_get_impl<T>(\n+ slot_id_preimage: u64,\n+)\n+where\n+ T: Eq + TestInstance + AbiEncode,\n+{\n+ let vec: StorageKey<StorageVec<StorageVec<T>>> = StorageKey::new(sha256(slot_id_preimage), 0, sha256(slot_id_preimage + 100));\n+\n+ let mut i = 0;\n+ while i < NUM_OF_NESTED_VECTORS {\n+ vec.push(StorageVec {});\n+ i += 1;\n+ }\n+\n+ assert(NUM_OF_NESTED_VECTORS == vec.len());\n+\n+ let expected_values = T::instances(NUM_OF_ELEMENTS);\n+ let mut i = 0;\n+ while i < NUM_OF_NESTED_VECTORS {\n+ let nested_vec = vec.get(i).unwrap();\n+ let mut j = 0;\n+ while j < NUM_OF_ELEMENTS {\n+ nested_vec.push(expected_values.get(j).unwrap());\n+ j += 1;\n+ }\n+ i += 1;\n+ }\n+\n+ let mut i = 0;\n+ while i < NUM_OF_NESTED_VECTORS {\n+ let nested_vec = vec.get(i).unwrap();\n+\n+ let mut j = 0;\n+ while j < NUM_OF_ELEMENTS {\n+ assert(expected_values.get(j).unwrap() == nested_vec.get(j).unwrap().read());\n+ j += 1;\n+ }\n+\n+ i += 1;\n+ }\n+}\n+\n+impl Contract {\n+ // Note that zero-sized types like, e.g., `()`, `[u64;0]`, or `EmptyStruct`,\n+ // by definition of the storage access semantics, cannot be stored in\n+ // a `StorageVec<T>`. If the `T` is zero-sized it must be an another\n+ // nested storage type, e.g., `StorageVec<StorageMap<u64, b256>>`.\n+ // So, in all the tests below, we don't have zero-sized types.\n+\n+ #[storage(read, write)]\n+ fn assert_push_and_get() {\n+ assert_push_and_get_impl::<bool>(1);\n+ assert_push_and_get_impl::<u8>(2);\n+ assert_push_and_get_impl::<u16>(3);\n+ assert_push_and_get_impl::<u32>(4);\n+ assert_push_and_get_impl::<u64>(5);\n+ assert_push_and_get_impl::<u256>(6);\n+ assert_push_and_get_impl::<b256>(7);\n+ assert_push_and_get_impl::<raw_slice>(8);\n+ assert_push_and_get_impl::<str>(9);\n+ assert_push_and_get_impl::<str[2]>(10);\n+ assert_push_and_get_impl::<str[5]>(11);\n+ assert_push_and_get_impl::<str[6]>(12);\n+ assert_push_and_get_impl::<str[8]>(13);\n+ assert_push_and_get_impl::<str[12]>(14);\n+ assert_push_and_get_impl::<str[13]>(15);\n+ assert_push_and_get_impl::<[u64; 2]>(16);\n+ assert_push_and_get_impl::<ArrayU8Len2>(17);\n+ assert_push_and_get_impl::<ArrayU8Len5>(18);\n+ assert_push_and_get_impl::<ArrayU8Len6>(19);\n+ assert_push_and_get_impl::<ArrayU8Len8>(20);\n+ assert_push_and_get_impl::<ArrayU8Len12>(21);\n+ assert_push_and_get_impl::<ArrayU8Len13>(22);\n+ assert_push_and_get_impl::<ArrayU64Len3>(23);\n+ assert_push_and_get_impl::<ArrayNestedArrayU8Len2Len3>(24);\n+ assert_push_and_get_impl::<ArrayStructBLen2>(25);\n+ assert_push_and_get_impl::<RawPtrNewtype>(26);\n+ assert_push_and_get_impl::<StructA>(27);\n+ assert_push_and_get_impl::<StructB>(28);\n+ assert_push_and_get_impl::<EnumSingleU8>(29);\n+ assert_push_and_get_impl::<EnumSingleU64>(30);\n+ assert_push_and_get_impl::<EnumSingleBool>(31);\n+ assert_push_and_get_impl::<EnumMultiUnits>(32);\n+ assert_push_and_get_impl::<EnumMultiOneByte>(33);\n+ assert_push_and_get_impl::<EnumU8AndU64>(34);\n+ assert_push_and_get_impl::<EnumQuadSlotSize>(35);\n+ assert_push_and_get_impl::<EnumLargerThanQuadSlot>(36);\n+ assert_push_and_get_impl::<(u8, u32)>(37);\n+ }\n+}\n+\n+#[test]\n+fn push_and_get() {\n+ let contract_abi = abi(StorageVecOfStorageVecContractTestsAbi, CONTRACT_ID);\n+ contract_abi.assert_push_and_get();\n+}\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_push_pop_get_len_first_last_is_empty_contract_tests/Forc.toml b/test/src/in_language_tests/test_programs/storage_vec_push_pop_get_len_first_last_is_empty_contract_tests/Forc.toml\nnew file mode 100644\nindex 00000000000..8f64fac94ba\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_vec_push_pop_get_len_first_last_is_empty_contract_tests/Forc.toml\n@@ -0,0 +1,9 @@\n+[project]\n+authors = [\"Fuel Labs <contact@fuel.sh>\"]\n+entry = \"main.sw\"\n+license = \"Apache-2.0\"\n+name = \"storage_vec_push_pop_get_len_first_last_is_empty_contract_tests\"\n+\n+[dependencies]\n+std = { path = \"../../../../../sway-lib-std\" }\n+test_types = { path = \"../test_types\" }\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_push_pop_get_len_first_last_is_empty_contract_tests/src/main.sw b/test/src/in_language_tests/test_programs/storage_vec_push_pop_get_len_first_last_is_empty_contract_tests/src/main.sw\nnew file mode 100644\nindex 00000000000..a6bc21ee19a\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_vec_push_pop_get_len_first_last_is_empty_contract_tests/src/main.sw\n@@ -0,0 +1,137 @@\n+// TODO: The initial reason for having several `storage_vec` tests is\n+// reaching the limit in the data section size of a single contract\n+// that contained all the tests for `StorageVec<T>` methods.\n+// See: https://github.com/FuelLabs/sway/issues/7612\n+// But even when the issue is solved, it perhaps still makes sense to have\n+// separate test projects for better organization and readability\n+// of the tests.\n+// TODO: Replace `assert(x == y)` back with `assert_eq(x, y)` once `assert_eq` no longer\n+// causes data-section explosion. See also: https://github.com/FuelLabs/sway/issues/7612\n+contract;\n+\n+use test_types::*;\n+\n+use std::hash::{Hash, sha256};\n+use std::storage::storage_vec::*;\n+\n+/// Default number of vector elements to use in tests.\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+const NUM_OF_ELEMENTS: u64 = 11;\n+\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+#[storage(read, write)]\n+fn assert_push_pop_get_len_first_last_is_empty_impl<T>(\n+ slot_id_preimage: u64,\n+)\n+where\n+ T: Eq + TestInstance + AbiEncode,\n+{\n+ assert_non_zero_sized_type::<T>();\n+\n+ let vec: StorageKey<StorageVec<T>> = StorageKey::new(sha256(slot_id_preimage), 0, sha256(slot_id_preimage + 100));\n+\n+ let expected_values = T::instances(NUM_OF_ELEMENTS);\n+\n+ assert(0 == vec.len());\n+ assert(vec.is_empty());\n+ assert(vec.first().is_none());\n+ assert(vec.last().is_none());\n+\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ vec.push(expected_values.get(i).unwrap());\n+ assert(i + 1 == vec.len());\n+ assert(!vec.is_empty());\n+ assert(expected_values.get(0) == vec.first().unwrap().try_read());\n+ assert(expected_values.get(i) == vec.last().unwrap().try_read());\n+ i += 1;\n+ }\n+\n+ assert(NUM_OF_ELEMENTS == vec.len());\n+\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ assert(expected_values.get(i) == vec.get(i).unwrap().try_read());\n+ i += 1;\n+ }\n+\n+ let mut i = NUM_OF_ELEMENTS;\n+ while i > 0 {\n+ i -= 1;\n+ assert(expected_values.get(i) == vec.pop());\n+ assert(i == vec.len());\n+ if i > 0 {\n+ assert(!vec.is_empty());\n+ assert(expected_values.get(0) == vec.first().unwrap().try_read());\n+ assert(expected_values.get(i - 1) == vec.last().unwrap().try_read());\n+ } else {\n+ assert(vec.is_empty());\n+ assert(vec.first().is_none());\n+ assert(vec.last().is_none());\n+ }\n+ }\n+\n+ assert(None == vec.pop());\n+ assert(None == vec.pop());\n+\n+ assert(0 == vec.len());\n+ assert(vec.is_empty());\n+ assert(vec.first().is_none());\n+ assert(vec.last().is_none());\n+}\n+\n+impl Contract {\n+ // Note that zero-sized types like, e.g., `()`, `[u64;0]`, or `EmptyStruct`,\n+ // by definition of the storage access semantics, cannot be stored in\n+ // a `StorageVec<T>`. If the `T` is zero-sized it must be an another\n+ // nested storage type, e.g., `StorageVec<StorageMap<u64, b256>>`.\n+ // So, in all the tests below, we don't have zero-sized types.\n+\n+ #[storage(read, write)]\n+ fn assert_push_pop_get_len_first_last_is_empty() {\n+ assert_push_pop_get_len_first_last_is_empty_impl::<bool>(1);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<u8>(2);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<u16>(3);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<u32>(4);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<u64>(5);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<u256>(6);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<b256>(7);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<raw_slice>(8);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<str>(9);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<str[2]>(10);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<str[5]>(11);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<str[6]>(12);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<str[8]>(13);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<str[12]>(14);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<str[13]>(15);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<[u64; 2]>(16);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<ArrayU8Len2>(17);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<ArrayU8Len5>(18);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<ArrayU8Len6>(19);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<ArrayU8Len8>(20);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<ArrayU8Len12>(21);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<ArrayU8Len13>(22);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<ArrayU64Len3>(23);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<ArrayNestedArrayU8Len2Len3>(24);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<ArrayStructBLen2>(25);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<RawPtrNewtype>(26);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<StructA>(27);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<StructB>(28);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<EnumSingleU8>(29);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<EnumSingleU64>(30);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<EnumSingleBool>(31);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<EnumMultiUnits>(32);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<EnumMultiOneByte>(33);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<EnumU8AndU64>(34);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<EnumQuadSlotSize>(35);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<EnumLargerThanQuadSlot>(36);\n+ assert_push_pop_get_len_first_last_is_empty_impl::<(u8, u32)>(37);\n+ }\n+\n+}\n+\n+#[test]\n+fn push_pop_get_len_first_last_is_empty() {\n+ let caller = abi(StorageVecPushPopGetLenFirstLastIsEmptyContractTestsAbi, CONTRACT_ID);\n+ caller.assert_push_pop_get_len_first_last_is_empty();\n+}\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_remove_contract_tests/Forc.toml b/test/src/in_language_tests/test_programs/storage_vec_remove_contract_tests/Forc.toml\nnew file mode 100644\nindex 00000000000..51f98f4a1c5\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_vec_remove_contract_tests/Forc.toml\n@@ -0,0 +1,9 @@\n+[project]\n+authors = [\"Fuel Labs <contact@fuel.sh>\"]\n+entry = \"main.sw\"\n+license = \"Apache-2.0\"\n+name = \"storage_vec_remove_contract_tests\"\n+\n+[dependencies]\n+std = { path = \"../../../../../sway-lib-std\" }\n+test_types = { path = \"../test_types\" }\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_remove_contract_tests/src/main.sw b/test/src/in_language_tests/test_programs/storage_vec_remove_contract_tests/src/main.sw\nnew file mode 100644\nindex 00000000000..b83ac80c2d2\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_vec_remove_contract_tests/src/main.sw\n@@ -0,0 +1,168 @@\n+// TODO: The initial reason for having several `storage_vec` tests is\n+// reaching the limit in the data section size of a single contract\n+// that contained all the tests for `StorageVec<T>` methods.\n+// See: https://github.com/FuelLabs/sway/issues/7612\n+// But even when the issue is solved, it perhaps still makes sense to have\n+// separate test projects for better organization and readability\n+// of the tests.\n+// TODO: Replace `assert(x == y)` back with `assert_eq(x, y)` once `assert_eq` no longer\n+// causes data-section explosion. See also: https://github.com/FuelLabs/sway/issues/7612\n+contract;\n+\n+use test_types::*;\n+\n+use std::hash::{Hash, sha256};\n+use std::storage::storage_vec::*;\n+\n+/// Default number of vector elements to use in tests.\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+const NUM_OF_ELEMENTS: u64 = 11;\n+\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+#[storage(read, write)]\n+fn assert_remove_impl<T>(\n+ slot_id_preimage: u64,\n+)\n+where\n+ T: Eq + TestInstance + AbiEncode,\n+{\n+ assert_non_zero_sized_type::<T>();\n+\n+ let vec: StorageKey<StorageVec<T>> = StorageKey::new(sha256(slot_id_preimage), 0, sha256(slot_id_preimage + 100));\n+\n+ let expected_values = T::instances(NUM_OF_ELEMENTS);\n+\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ vec.push(expected_values.get(i).unwrap());\n+ i += 1;\n+ }\n+\n+ // Remove front element and verify left shift.\n+ let removed_front = vec.remove(0);\n+ assert(expected_values.get(0).unwrap() == removed_front);\n+ assert(NUM_OF_ELEMENTS - 1 == vec.len());\n+\n+ let mut i = 0;\n+ while i < vec.len() {\n+ assert(expected_values.get(i + 1) == vec.get(i).unwrap().try_read());\n+ i += 1;\n+ }\n+\n+ // Remove middle element and verify left shift around removed index.\n+ let middle_index = vec.len() / 2;\n+ let removed_middle = vec.remove(middle_index);\n+ assert(expected_values.get(middle_index + 1).unwrap() == removed_middle);\n+ assert(NUM_OF_ELEMENTS - 2 == vec.len());\n+\n+ let mut i = 0;\n+ while i < middle_index {\n+ assert(expected_values.get(i + 1) == vec.get(i).unwrap().try_read());\n+ i += 1;\n+ }\n+\n+ let mut i = middle_index;\n+ while i < vec.len() {\n+ assert(expected_values.get(i + 2) == vec.get(i).unwrap().try_read());\n+ i += 1;\n+ }\n+\n+ // Remove last element.\n+ let removed_last = vec.remove(vec.len() - 1);\n+ assert(expected_values.get(NUM_OF_ELEMENTS - 1).unwrap() == removed_last);\n+ assert(NUM_OF_ELEMENTS - 3 == vec.len());\n+\n+ // Verify final content after front, middle and last removals.\n+ let mut i = 0;\n+ while i < middle_index {\n+ assert(expected_values.get(i + 1) == vec.get(i).unwrap().try_read());\n+ i += 1;\n+ }\n+\n+ let mut i = middle_index;\n+ while i < vec.len() {\n+ assert(expected_values.get(i + 2) == vec.get(i).unwrap().try_read());\n+ i += 1;\n+ }\n+}\n+\n+impl Contract {\n+ // Note that zero-sized types like, e.g., `()`, `[u64;0]`, or `EmptyStruct`,\n+ // by definition of the storage access semantics, cannot be stored in\n+ // a `StorageVec<T>`. If the `T` is zero-sized it must be an another\n+ // nested storage type, e.g., `StorageVec<StorageMap<u64, b256>>`.\n+ // So, in all the tests below, we don't have zero-sized types.\n+\n+ #[storage(read, write)]\n+ fn assert_remove() {\n+ assert_remove_impl::<bool>(1);\n+ assert_remove_impl::<u8>(2);\n+ assert_remove_impl::<u16>(3);\n+ assert_remove_impl::<u32>(4);\n+ assert_remove_impl::<u64>(5);\n+ assert_remove_impl::<u256>(6);\n+ assert_remove_impl::<b256>(7);\n+ assert_remove_impl::<raw_slice>(8);\n+ assert_remove_impl::<str>(9);\n+ assert_remove_impl::<str[2]>(10);\n+ assert_remove_impl::<str[5]>(11);\n+ assert_remove_impl::<str[6]>(12);\n+ assert_remove_impl::<str[8]>(13);\n+ assert_remove_impl::<str[12]>(14);\n+ assert_remove_impl::<str[13]>(15);\n+ assert_remove_impl::<[u64; 2]>(16);\n+ assert_remove_impl::<ArrayU8Len2>(17);\n+ assert_remove_impl::<ArrayU8Len5>(18);\n+ assert_remove_impl::<ArrayU8Len6>(19);\n+ assert_remove_impl::<ArrayU8Len8>(20);\n+ assert_remove_impl::<ArrayU8Len12>(21);\n+ assert_remove_impl::<ArrayU8Len13>(22);\n+ assert_remove_impl::<ArrayU64Len3>(23);\n+ assert_remove_impl::<ArrayNestedArrayU8Len2Len3>(24);\n+ assert_remove_impl::<ArrayStructBLen2>(25);\n+ assert_remove_impl::<RawPtrNewtype>(26);\n+ assert_remove_impl::<StructA>(27);\n+ assert_remove_impl::<StructB>(28);\n+ assert_remove_impl::<EnumSingleU8>(29);\n+ assert_remove_impl::<EnumSingleU64>(30);\n+ assert_remove_impl::<EnumSingleBool>(31);\n+ assert_remove_impl::<EnumMultiUnits>(32);\n+ assert_remove_impl::<EnumMultiOneByte>(33);\n+ assert_remove_impl::<EnumU8AndU64>(34);\n+ assert_remove_impl::<EnumQuadSlotSize>(35);\n+ assert_remove_impl::<EnumLargerThanQuadSlot>(36);\n+ assert_remove_impl::<(u8, u32)>(37);\n+ }\n+\n+ #[storage(read, write)]\n+ fn assert_remove_index_out_of_bounds() {\n+ let vec: StorageKey<StorageVec<u64>> = StorageKey::new(b256::zero(), 0, b256::zero());\n+ let _ = vec.remove(0);\n+ }\n+\n+ #[storage(read, write)]\n+ fn assert_remove_nested_storage_type() {\n+ let vec: StorageKey<StorageVec<StorageVec<u64>>> = StorageKey::new(b256::zero(), 0, b256::zero());\n+ vec.push(StorageVec {});\n+ let _ = vec.remove(0); // Nested storage types cannot be removed.\n+ }\n+\n+}\n+\n+#[test]\n+fn remove() {\n+ let caller = abi(StorageVecRemoveContractTestsAbi, CONTRACT_ID);\n+ caller.assert_remove();\n+}\n+\n+#[test(should_revert)]\n+fn remove_out_of_bounds() {\n+ let caller = abi(StorageVecRemoveContractTestsAbi, CONTRACT_ID);\n+ caller.assert_remove_index_out_of_bounds();\n+}\n+\n+#[test(should_revert)]\n+fn remove_nested_storage_type() {\n+ let caller = abi(StorageVecRemoveContractTestsAbi, CONTRACT_ID);\n+ caller.assert_remove_nested_storage_type();\n+}\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_resize_contract_tests/Forc.toml b/test/src/in_language_tests/test_programs/storage_vec_resize_contract_tests/Forc.toml\nnew file mode 100644\nindex 00000000000..a7957a7f0dd\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_vec_resize_contract_tests/Forc.toml\n@@ -0,0 +1,9 @@\n+[project]\n+authors = [\"Fuel Labs <contact@fuel.sh>\"]\n+entry = \"main.sw\"\n+license = \"Apache-2.0\"\n+name = \"storage_vec_resize_contract_tests\"\n+\n+[dependencies]\n+std = { path = \"../../../../../sway-lib-std\" }\n+test_types = { path = \"../test_types\" }\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_resize_contract_tests/src/main.sw b/test/src/in_language_tests/test_programs/storage_vec_resize_contract_tests/src/main.sw\nnew file mode 100644\nindex 00000000000..a0bae8991e7\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_vec_resize_contract_tests/src/main.sw\n@@ -0,0 +1,150 @@\n+// TODO: The initial reason for having several `storage_vec` tests is\n+// reaching the limit in the data section size of a single contract\n+// that contained all the tests for `StorageVec<T>` methods.\n+// See: https://github.com/FuelLabs/sway/issues/7612\n+// But even when the issue is solved, it perhaps still makes sense to have\n+// separate test projects for better organization and readability\n+// of the tests.\n+// TODO: Replace `assert(x == y)` back with `assert_eq(x, y)` once `assert_eq` no longer\n+// causes data-section explosion. See also: https://github.com/FuelLabs/sway/issues/7612\n+contract;\n+\n+use test_types::*;\n+\n+use std::hash::{Hash, sha256};\n+use std::storage::storage_vec::*;\n+\n+/// Default number of vector elements to use in tests.\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+const NUM_OF_ELEMENTS: u64 = 11;\n+\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+#[storage(read, write)]\n+fn assert_resize_impl<T>(\n+ slot_id_preimage: u64,\n+)\n+where\n+ T: Eq + TestInstance + AbiEncode,\n+{\n+ assert_non_zero_sized_type::<T>();\n+\n+ let vec: StorageKey<StorageVec<T>> = StorageKey::new(sha256(slot_id_preimage), 0, sha256(slot_id_preimage + 100));\n+\n+ let expected_values = T::instances(NUM_OF_ELEMENTS);\n+\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ vec.push(expected_values.get(i).unwrap());\n+ i += 1;\n+ }\n+\n+ // Grow and verify appended values are set to `value`.\n+ let grow_value = expected_values.get(NUM_OF_ELEMENTS / 2).unwrap();\n+ vec.resize(NUM_OF_ELEMENTS + 2, grow_value);\n+ assert(NUM_OF_ELEMENTS + 2 == vec.len());\n+\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ assert(expected_values.get(i) == vec.get(i).unwrap().try_read());\n+ i += 1;\n+ }\n+ assert(grow_value == vec.get(NUM_OF_ELEMENTS).unwrap().read());\n+ assert(grow_value == vec.get(NUM_OF_ELEMENTS + 1).unwrap().read());\n+\n+ // Truncate and verify prefix is preserved.\n+ vec.resize(NUM_OF_ELEMENTS - 2, T::default());\n+ assert(NUM_OF_ELEMENTS - 2 == vec.len());\n+\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS - 2 {\n+ assert(expected_values.get(i) == vec.get(i).unwrap().try_read());\n+ i += 1;\n+ }\n+\n+ // Resize to zero, then grow from empty.\n+ vec.resize(0, T::default());\n+ assert(0 == vec.len());\n+\n+ let from_empty_value = expected_values.get(0).unwrap();\n+ vec.resize(2, from_empty_value);\n+ assert(2 == vec.len());\n+ assert(from_empty_value == vec.get(0).unwrap().read());\n+ assert(from_empty_value == vec.get(1).unwrap().read());\n+}\n+\n+impl Contract {\n+ // Note that zero-sized types like, e.g., `()`, `[u64;0]`, or `EmptyStruct`,\n+ // by definition of the storage access semantics, cannot be stored in\n+ // a `StorageVec<T>`. If the `T` is zero-sized it must be an another\n+ // nested storage type, e.g., `StorageVec<StorageMap<u64, b256>>`.\n+ // So, in all the tests below, we don't have zero-sized types.\n+\n+ #[storage(read, write)]\n+ fn assert_resize() {\n+ assert_resize_impl::<bool>(1);\n+ assert_resize_impl::<u8>(2);\n+ assert_resize_impl::<u16>(3);\n+ assert_resize_impl::<u32>(4);\n+ assert_resize_impl::<u64>(5);\n+ assert_resize_impl::<u256>(6);\n+ assert_resize_impl::<b256>(7);\n+ assert_resize_impl::<raw_slice>(8);\n+ assert_resize_impl::<str>(9);\n+ assert_resize_impl::<str[2]>(10);\n+ assert_resize_impl::<str[5]>(11);\n+ assert_resize_impl::<str[6]>(12);\n+ assert_resize_impl::<str[8]>(13);\n+ assert_resize_impl::<str[12]>(14);\n+ assert_resize_impl::<str[13]>(15);\n+ assert_resize_impl::<[u64; 2]>(16);\n+ assert_resize_impl::<ArrayU8Len2>(17);\n+ assert_resize_impl::<ArrayU8Len5>(18);\n+ assert_resize_impl::<ArrayU8Len6>(19);\n+ assert_resize_impl::<ArrayU8Len8>(20);\n+ assert_resize_impl::<ArrayU8Len12>(21);\n+ assert_resize_impl::<ArrayU8Len13>(22);\n+ assert_resize_impl::<ArrayU64Len3>(23);\n+ assert_resize_impl::<ArrayNestedArrayU8Len2Len3>(24);\n+ assert_resize_impl::<ArrayStructBLen2>(25);\n+ assert_resize_impl::<RawPtrNewtype>(26);\n+ assert_resize_impl::<StructA>(27);\n+ assert_resize_impl::<StructB>(28);\n+ assert_resize_impl::<EnumSingleU8>(29);\n+ assert_resize_impl::<EnumSingleU64>(30);\n+ assert_resize_impl::<EnumSingleBool>(31);\n+ assert_resize_impl::<EnumMultiUnits>(32);\n+ assert_resize_impl::<EnumMultiOneByte>(33);\n+ assert_resize_impl::<EnumU8AndU64>(34);\n+ assert_resize_impl::<EnumQuadSlotSize>(35);\n+ assert_resize_impl::<EnumLargerThanQuadSlot>(36);\n+ assert_resize_impl::<(u8, u32)>(37);\n+ }\n+\n+ #[storage(read, write)]\n+ fn assert_resize_nested_storage_type() {\n+ let vec: StorageKey<StorageVec<StorageVec<u64>>> = StorageKey::new(b256::zero(), 0, b256::zero());\n+\n+ // Resize a nested-storage-type vector; only the length is adjusted.\n+ vec.resize(3, StorageVec {});\n+ assert(3 == vec.len());\n+\n+ vec.resize(1, StorageVec {});\n+ assert(1 == vec.len());\n+\n+ vec.resize(0, StorageVec {});\n+ assert(0 == vec.len());\n+ }\n+\n+}\n+\n+#[test]\n+fn resize() {\n+ let caller = abi(StorageVecResizeContractTestsAbi, CONTRACT_ID);\n+ caller.assert_resize();\n+}\n+\n+#[test]\n+fn resize_nested_storage_type() {\n+ let caller = abi(StorageVecResizeContractTestsAbi, CONTRACT_ID);\n+ caller.assert_resize_nested_storage_type();\n+}\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_reverse_contract_tests/Forc.toml b/test/src/in_language_tests/test_programs/storage_vec_reverse_contract_tests/Forc.toml\nnew file mode 100644\nindex 00000000000..a799688bf8d\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_vec_reverse_contract_tests/Forc.toml\n@@ -0,0 +1,9 @@\n+[project]\n+authors = [\"Fuel Labs <contact@fuel.sh>\"]\n+entry = \"main.sw\"\n+license = \"Apache-2.0\"\n+name = \"storage_vec_reverse_contract_tests\"\n+\n+[dependencies]\n+std = { path = \"../../../../../sway-lib-std\" }\n+test_types = { path = \"../test_types\" }\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_reverse_contract_tests/src/main.sw b/test/src/in_language_tests/test_programs/storage_vec_reverse_contract_tests/src/main.sw\nnew file mode 100644\nindex 00000000000..d93fa75cfa7\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_vec_reverse_contract_tests/src/main.sw\n@@ -0,0 +1,137 @@\n+// TODO: The initial reason for having several `storage_vec` tests is\n+// reaching the limit in the data section size of a single contract\n+// that contained all the tests for `StorageVec<T>` methods.\n+// See: https://github.com/FuelLabs/sway/issues/7612\n+// But even when the issue is solved, it perhaps still makes sense to have\n+// separate test projects for better organization and readability\n+// of the tests.\n+// TODO: Replace `assert(x == y)` back with `assert_eq(x, y)` once `assert_eq` no longer\n+// causes data-section explosion. See also: https://github.com/FuelLabs/sway/issues/7612\n+contract;\n+\n+use test_types::*;\n+\n+use std::hash::{Hash, sha256};\n+use std::storage::storage_vec::*;\n+\n+/// Default number of vector elements to use in tests.\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+const NUM_OF_ELEMENTS: u64 = 11;\n+\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+#[storage(read, write)]\n+fn assert_reverse_impl<T>(\n+ slot_id_preimage: u64,\n+)\n+where\n+ T: Eq + TestInstance + AbiEncode,\n+{\n+ assert_non_zero_sized_type::<T>();\n+\n+ let vec: StorageKey<StorageVec<T>> = StorageKey::new(sha256(slot_id_preimage), 0, sha256(slot_id_preimage + 100));\n+\n+ let expected_values = T::instances(NUM_OF_ELEMENTS);\n+\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ vec.push(expected_values.get(i).unwrap());\n+ i += 1;\n+ }\n+\n+ vec.reverse();\n+ assert(NUM_OF_ELEMENTS == vec.len());\n+\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ assert(expected_values.get(NUM_OF_ELEMENTS - i - 1) == vec.get(i).unwrap().try_read());\n+ i += 1;\n+ }\n+\n+ // Reverse back to original order.\n+ vec.reverse();\n+ assert(NUM_OF_ELEMENTS == vec.len());\n+\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ assert(expected_values.get(i) == vec.get(i).unwrap().try_read());\n+ i += 1;\n+ }\n+\n+ // Reversing empty and single-element vectors is a no-op.\n+ let _ = vec.clear();\n+ vec.reverse();\n+ assert(0 == vec.len());\n+\n+ vec.push(expected_values.get(0).unwrap());\n+ vec.reverse();\n+ assert(1 == vec.len());\n+ assert(expected_values.get(0) == vec.get(0).unwrap().try_read());\n+}\n+\n+impl Contract {\n+ // Note that zero-sized types like, e.g., `()`, `[u64;0]`, or `EmptyStruct`,\n+ // by definition of the storage access semantics, cannot be stored in\n+ // a `StorageVec<T>`. If the `T` is zero-sized it must be an another\n+ // nested storage type, e.g., `StorageVec<StorageMap<u64, b256>>`.\n+ // So, in all the tests below, we don't have zero-sized types.\n+\n+ #[storage(read, write)]\n+ fn assert_reverse() {\n+ assert_reverse_impl::<bool>(1);\n+ assert_reverse_impl::<u8>(2);\n+ assert_reverse_impl::<u16>(3);\n+ assert_reverse_impl::<u32>(4);\n+ assert_reverse_impl::<u64>(5);\n+ assert_reverse_impl::<u256>(6);\n+ assert_reverse_impl::<b256>(7);\n+ assert_reverse_impl::<raw_slice>(8);\n+ assert_reverse_impl::<str>(9);\n+ assert_reverse_impl::<str[2]>(10);\n+ assert_reverse_impl::<str[5]>(11);\n+ assert_reverse_impl::<str[6]>(12);\n+ assert_reverse_impl::<str[8]>(13);\n+ assert_reverse_impl::<str[12]>(14);\n+ assert_reverse_impl::<str[13]>(15);\n+ assert_reverse_impl::<[u64; 2]>(16);\n+ assert_reverse_impl::<ArrayU8Len2>(17);\n+ assert_reverse_impl::<ArrayU8Len5>(18);\n+ assert_reverse_impl::<ArrayU8Len6>(19);\n+ assert_reverse_impl::<ArrayU8Len8>(20);\n+ assert_reverse_impl::<ArrayU8Len12>(21);\n+ assert_reverse_impl::<ArrayU8Len13>(22);\n+ assert_reverse_impl::<ArrayU64Len3>(23);\n+ assert_reverse_impl::<ArrayNestedArrayU8Len2Len3>(24);\n+ assert_reverse_impl::<ArrayStructBLen2>(25);\n+ assert_reverse_impl::<RawPtrNewtype>(26);\n+ assert_reverse_impl::<StructA>(27);\n+ assert_reverse_impl::<StructB>(28);\n+ assert_reverse_impl::<EnumSingleU8>(29);\n+ assert_reverse_impl::<EnumSingleU64>(30);\n+ assert_reverse_impl::<EnumSingleBool>(31);\n+ assert_reverse_impl::<EnumMultiUnits>(32);\n+ assert_reverse_impl::<EnumMultiOneByte>(33);\n+ assert_reverse_impl::<EnumU8AndU64>(34);\n+ assert_reverse_impl::<EnumQuadSlotSize>(35);\n+ assert_reverse_impl::<EnumLargerThanQuadSlot>(36);\n+ assert_reverse_impl::<(u8, u32)>(37);\n+ }\n+\n+ #[storage(write)]\n+ fn assert_reverse_nested_storage_type() {\n+ let vec: StorageKey<StorageVec<StorageVec<u64>>> = StorageKey::new(b256::zero(), 0, b256::zero());\n+ vec.reverse(); // Nested storage types cannot be reversed.\n+ }\n+\n+}\n+\n+#[test]\n+fn reverse() {\n+ let caller = abi(StorageVecReverseContractTestsAbi, CONTRACT_ID);\n+ caller.assert_reverse();\n+}\n+\n+#[test(should_revert)]\n+fn reverse_nested_storage_type() {\n+ let caller = abi(StorageVecReverseContractTestsAbi, CONTRACT_ID);\n+ caller.assert_reverse_nested_storage_type();\n+}\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_iter_tests/Forc.toml b/test/src/in_language_tests/test_programs/storage_vec_set_contract_tests/Forc.toml\nsimilarity index 66%\nrename from test/src/in_language_tests/test_programs/storage_vec_iter_tests/Forc.toml\nrename to test/src/in_language_tests/test_programs/storage_vec_set_contract_tests/Forc.toml\nindex 8957a7ce609..b85b0ff7142 100644\n--- a/test/src/in_language_tests/test_programs/storage_vec_iter_tests/Forc.toml\n+++ b/test/src/in_language_tests/test_programs/storage_vec_set_contract_tests/Forc.toml\n@@ -2,7 +2,8 @@\n authors = [\"Fuel Labs <contact@fuel.sh>\"]\n entry = \"main.sw\"\n license = \"Apache-2.0\"\n-name = \"storage_vec_iter_tests\"\n+name = \"storage_vec_set_contract_tests\"\n \n [dependencies]\n std = { path = \"../../../../../sway-lib-std\" }\n+test_types = { path = \"../test_types\" }\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_set_contract_tests/src/main.sw b/test/src/in_language_tests/test_programs/storage_vec_set_contract_tests/src/main.sw\nnew file mode 100644\nindex 00000000000..04b27b5830f\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_vec_set_contract_tests/src/main.sw\n@@ -0,0 +1,135 @@\n+// TODO: The initial reason for having several `storage_vec` tests is\n+// reaching the limit in the data section size of a single contract\n+// that contained all the tests for `StorageVec<T>` methods.\n+// See: https://github.com/FuelLabs/sway/issues/7612\n+// But even when the issue is solved, it perhaps still makes sense to have\n+// separate test projects for better organization and readability\n+// of the tests.\n+// TODO: Replace `assert(x == y)` back with `assert_eq(x, y)` once `assert_eq` no longer\n+// causes data-section explosion. See also: https://github.com/FuelLabs/sway/issues/7612\n+contract;\n+\n+use test_types::*;\n+\n+use std::hash::{Hash, sha256};\n+use std::storage::storage_vec::*;\n+\n+/// Default number of vector elements to use in tests.\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+const NUM_OF_ELEMENTS: u64 = 11;\n+\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+#[storage(read, write)]\n+fn assert_set_impl<T>(\n+ slot_id_preimage: u64,\n+)\n+where\n+ T: Eq + TestInstance + AbiEncode,\n+{\n+ assert_non_zero_sized_type::<T>();\n+\n+ let vec: StorageKey<StorageVec<T>> = StorageKey::new(sha256(slot_id_preimage), 0, sha256(slot_id_preimage + 100));\n+\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ vec.push(T::default());\n+ i += 1;\n+ }\n+\n+ let expected_values = T::instances(NUM_OF_ELEMENTS);\n+\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ vec.set(i, expected_values.get(i).unwrap());\n+ assert(expected_values.get(i) == vec.get(i).unwrap().try_read());\n+ assert(NUM_OF_ELEMENTS == vec.len());\n+ i += 1;\n+ }\n+\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ assert(expected_values.get(i) == vec.get(i).unwrap().try_read());\n+ i += 1;\n+ }\n+}\n+\n+impl Contract {\n+ // Note that zero-sized types like, e.g., `()`, `[u64;0]`, or `EmptyStruct`,\n+ // by definition of the storage access semantics, cannot be stored in\n+ // a `StorageVec<T>`. If the `T` is zero-sized it must be an another\n+ // nested storage type, e.g., `StorageVec<StorageMap<u64, b256>>`.\n+ // So, in all the tests below, we don't have zero-sized types.\n+\n+ #[storage(read, write)]\n+ fn assert_set() {\n+ assert_set_impl::<bool>(1);\n+ assert_set_impl::<u8>(2);\n+ assert_set_impl::<u16>(3);\n+ assert_set_impl::<u32>(4);\n+ assert_set_impl::<u64>(5);\n+ assert_set_impl::<u256>(6);\n+ assert_set_impl::<b256>(7);\n+ assert_set_impl::<raw_slice>(8);\n+ assert_set_impl::<str>(9);\n+ assert_set_impl::<str[2]>(10);\n+ assert_set_impl::<str[5]>(11);\n+ assert_set_impl::<str[6]>(12);\n+ assert_set_impl::<str[8]>(13);\n+ assert_set_impl::<str[12]>(14);\n+ assert_set_impl::<str[13]>(15);\n+ assert_set_impl::<[u64; 2]>(16);\n+ assert_set_impl::<ArrayU8Len2>(17);\n+ assert_set_impl::<ArrayU8Len5>(18);\n+ assert_set_impl::<ArrayU8Len6>(19);\n+ assert_set_impl::<ArrayU8Len8>(20);\n+ assert_set_impl::<ArrayU8Len12>(21);\n+ assert_set_impl::<ArrayU8Len13>(22);\n+ assert_set_impl::<ArrayU64Len3>(23);\n+ assert_set_impl::<ArrayNestedArrayU8Len2Len3>(24);\n+ assert_set_impl::<ArrayStructBLen2>(25);\n+ assert_set_impl::<RawPtrNewtype>(26);\n+ assert_set_impl::<StructA>(27);\n+ assert_set_impl::<StructB>(28);\n+ assert_set_impl::<EnumSingleU8>(29);\n+ assert_set_impl::<EnumSingleU64>(30);\n+ assert_set_impl::<EnumSingleBool>(31);\n+ assert_set_impl::<EnumMultiUnits>(32);\n+ assert_set_impl::<EnumMultiOneByte>(33);\n+ assert_set_impl::<EnumU8AndU64>(34);\n+ assert_set_impl::<EnumQuadSlotSize>(35);\n+ assert_set_impl::<EnumLargerThanQuadSlot>(36);\n+ assert_set_impl::<(u8, u32)>(37);\n+ }\n+\n+ #[storage(read, write)]\n+ fn assert_set_index_out_of_bounds() {\n+ let vec: StorageKey<StorageVec<u64>> = StorageKey::new(b256::zero(), 0, b256::zero());\n+ vec.set(0, 42);\n+ }\n+\n+ #[storage(read, write)]\n+ fn assert_set_nested_storage_type() {\n+ let vec: StorageKey<StorageVec<StorageVec<u64>>> = StorageKey::new(b256::zero(), 0, b256::zero());\n+ vec.push(StorageVec {});\n+ vec.set(0, StorageVec {}); // Nested storage types cannot be set.\n+ }\n+\n+}\n+\n+#[test]\n+fn set() {\n+ let caller = abi(StorageVecSetContractTestsAbi, CONTRACT_ID);\n+ caller.assert_set();\n+}\n+\n+#[test(should_revert)]\n+fn set_out_of_bounds() {\n+ let caller = abi(StorageVecSetContractTestsAbi, CONTRACT_ID);\n+ caller.assert_set_index_out_of_bounds();\n+}\n+\n+#[test(should_revert)]\n+fn set_nested_storage_type() {\n+ let caller = abi(StorageVecSetContractTestsAbi, CONTRACT_ID);\n+ caller.assert_set_nested_storage_type();\n+}\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_store_vec_contract_tests/Forc.toml b/test/src/in_language_tests/test_programs/storage_vec_store_vec_contract_tests/Forc.toml\nnew file mode 100644\nindex 00000000000..c3ddb63d226\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_vec_store_vec_contract_tests/Forc.toml\n@@ -0,0 +1,9 @@\n+[project]\n+authors = [\"Fuel Labs <contact@fuel.sh>\"]\n+entry = \"main.sw\"\n+license = \"Apache-2.0\"\n+name = \"storage_vec_store_vec_contract_tests\"\n+\n+[dependencies]\n+std = { path = \"../../../../../sway-lib-std\" }\n+test_types = { path = \"../test_types\" }\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_store_vec_contract_tests/src/main.sw b/test/src/in_language_tests/test_programs/storage_vec_store_vec_contract_tests/src/main.sw\nnew file mode 100644\nindex 00000000000..35b8c77bdf8\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_vec_store_vec_contract_tests/src/main.sw\n@@ -0,0 +1,160 @@\n+// TODO: The initial reason for having several `storage_vec` tests is\n+// reaching the limit in the data section size of a single contract\n+// that contained all the tests for `StorageVec<T>` methods.\n+// See: https://github.com/FuelLabs/sway/issues/7612\n+// But even when the issue is solved, it perhaps still makes sense to have\n+// separate test projects for better organization and readability\n+// of the tests.\n+// TODO: Replace `assert(x == y)` back with `assert_eq(x, y)` once `assert_eq` no longer\n+// causes data-section explosion. See also: https://github.com/FuelLabs/sway/issues/7612\n+contract;\n+\n+use test_types::*;\n+\n+use std::hash::{Hash, sha256};\n+use std::storage::storage_vec::*;\n+\n+/// Default number of vector elements to use in tests.\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+const NUM_OF_ELEMENTS: u64 = 11;\n+\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+#[storage(write)]\n+fn assert_store_vec_impl<T>(\n+ slot_id_preimage: u64,\n+)\n+where\n+ T: Eq + TestInstance + AbiEncode,\n+{\n+ assert_non_zero_sized_type::<T>();\n+\n+ let vec: StorageKey<StorageVec<T>> = StorageKey::new(sha256(slot_id_preimage), 0, sha256(slot_id_preimage + 100));\n+\n+ let expected_values = T::instances(NUM_OF_ELEMENTS);\n+\n+ // Store vector with content into empty storage vector and verify.\n+ let mut heap_vec = Vec::<T>::new();\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ heap_vec.push(expected_values.get(i).unwrap());\n+ i += 1;\n+ }\n+\n+ vec.store_vec(heap_vec);\n+ assert(NUM_OF_ELEMENTS == vec.len());\n+\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ assert(expected_values.get(i) == vec.get(i).unwrap().try_read());\n+ i += 1;\n+ }\n+\n+ // Store vector with less content into existing storage vector and verify.\n+ heap_vec.resize(NUM_OF_ELEMENTS / 2, T::default());\n+ vec.store_vec(heap_vec);\n+ assert(NUM_OF_ELEMENTS / 2 == vec.len());\n+\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS / 2 {\n+ assert(expected_values.get(i) == vec.get(i).unwrap().try_read());\n+ i += 1;\n+ }\n+\n+ // Store vector with more content into existing storage vector and verify.\n+ heap_vec.resize(NUM_OF_ELEMENTS, T::default());\n+ vec.store_vec(heap_vec);\n+ assert(NUM_OF_ELEMENTS == vec.len());\n+\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS / 2 {\n+ assert(expected_values.get(i) == vec.get(i).unwrap().try_read());\n+ i += 1;\n+ }\n+\n+ let mut i = NUM_OF_ELEMENTS / 2;\n+ while i < NUM_OF_ELEMENTS {\n+ assert(T::default() == vec.get(i).unwrap().read());\n+ i += 1;\n+ }\n+\n+ // Store empty vector into non-empty storage vector and verify.\n+ let empty_vec: Vec<T> = Vec::new();\n+ vec.store_vec(empty_vec);\n+ assert(0 == vec.len());\n+\n+ // Store single-element vector into empty storage vector and verify.\n+ let mut single_vec = Vec::<T>::new();\n+ single_vec.push(expected_values.get(0).unwrap());\n+ vec.store_vec(single_vec);\n+ assert(1 == vec.len());\n+ assert(expected_values.get(0) == vec.get(0).unwrap().try_read());\n+}\n+\n+impl Contract {\n+ // Note that zero-sized types like, e.g., `()`, `[u64;0]`, or `EmptyStruct`,\n+ // by definition of the storage access semantics, cannot be stored in\n+ // a `StorageVec<T>`. If the `T` is zero-sized it must be an another\n+ // nested storage type, e.g., `StorageVec<StorageMap<u64, b256>>`.\n+ // So, in all the tests below, we don't have zero-sized types.\n+\n+ #[storage(write)]\n+ fn assert_store_vec() {\n+ assert_store_vec_impl::<bool>(1);\n+ assert_store_vec_impl::<u8>(2);\n+ assert_store_vec_impl::<u16>(3);\n+ assert_store_vec_impl::<u32>(4);\n+ assert_store_vec_impl::<u64>(5);\n+ assert_store_vec_impl::<u256>(6);\n+ assert_store_vec_impl::<b256>(7);\n+ assert_store_vec_impl::<raw_slice>(8);\n+ assert_store_vec_impl::<str>(9);\n+ assert_store_vec_impl::<str[2]>(10);\n+ assert_store_vec_impl::<str[5]>(11);\n+ assert_store_vec_impl::<str[6]>(12);\n+ assert_store_vec_impl::<str[8]>(13);\n+ assert_store_vec_impl::<str[12]>(14);\n+ assert_store_vec_impl::<str[13]>(15);\n+ assert_store_vec_impl::<[u64; 2]>(16);\n+ assert_store_vec_impl::<ArrayU8Len2>(17);\n+ assert_store_vec_impl::<ArrayU8Len5>(18);\n+ assert_store_vec_impl::<ArrayU8Len6>(19);\n+ assert_store_vec_impl::<ArrayU8Len8>(20);\n+ assert_store_vec_impl::<ArrayU8Len12>(21);\n+ assert_store_vec_impl::<ArrayU8Len13>(22);\n+ assert_store_vec_impl::<ArrayU64Len3>(23);\n+ assert_store_vec_impl::<ArrayNestedArrayU8Len2Len3>(24);\n+ assert_store_vec_impl::<ArrayStructBLen2>(25);\n+ assert_store_vec_impl::<RawPtrNewtype>(26);\n+ assert_store_vec_impl::<StructA>(27);\n+ assert_store_vec_impl::<StructB>(28);\n+ assert_store_vec_impl::<EnumSingleU8>(29);\n+ assert_store_vec_impl::<EnumSingleU64>(30);\n+ assert_store_vec_impl::<EnumSingleBool>(31);\n+ assert_store_vec_impl::<EnumMultiUnits>(32);\n+ assert_store_vec_impl::<EnumMultiOneByte>(33);\n+ assert_store_vec_impl::<EnumU8AndU64>(34);\n+ assert_store_vec_impl::<EnumQuadSlotSize>(35);\n+ assert_store_vec_impl::<EnumLargerThanQuadSlot>(36);\n+ assert_store_vec_impl::<(u8, u32)>(37);\n+ }\n+\n+ #[storage(write)]\n+ fn assert_store_vec_nested_storage_type() {\n+ let vec: StorageKey<StorageVec<StorageVec<u64>>> = StorageKey::new(b256::zero(), 0, b256::zero());\n+ let heap_vec: Vec<StorageVec<u64>> = Vec::new();\n+ vec.store_vec(heap_vec); // Nested storage types cannot be stored.\n+ }\n+\n+}\n+\n+#[test]\n+fn store_vec() {\n+ let caller = abi(StorageVecStoreVecContractTestsAbi, CONTRACT_ID);\n+ caller.assert_store_vec();\n+}\n+\n+#[test(should_revert)]\n+fn store_vec_nested_storage_type() {\n+ let caller = abi(StorageVecStoreVecContractTestsAbi, CONTRACT_ID);\n+ caller.assert_store_vec_nested_storage_type();\n+}\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_swap_contract_tests/Forc.toml b/test/src/in_language_tests/test_programs/storage_vec_swap_contract_tests/Forc.toml\nnew file mode 100644\nindex 00000000000..2c204e067cc\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_vec_swap_contract_tests/Forc.toml\n@@ -0,0 +1,9 @@\n+[project]\n+authors = [\"Fuel Labs <contact@fuel.sh>\"]\n+entry = \"main.sw\"\n+license = \"Apache-2.0\"\n+name = \"storage_vec_swap_contract_tests\"\n+\n+[dependencies]\n+std = { path = \"../../../../../sway-lib-std\" }\n+test_types = { path = \"../test_types\" }\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_swap_contract_tests/src/main.sw b/test/src/in_language_tests/test_programs/storage_vec_swap_contract_tests/src/main.sw\nnew file mode 100644\nindex 00000000000..7b503e7a804\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_vec_swap_contract_tests/src/main.sw\n@@ -0,0 +1,160 @@\n+// TODO: The initial reason for having several `storage_vec` tests is\n+// reaching the limit in the data section size of a single contract\n+// that contained all the tests for `StorageVec<T>` methods.\n+// See: https://github.com/FuelLabs/sway/issues/7612\n+// But even when the issue is solved, it perhaps still makes sense to have\n+// separate test projects for better organization and readability\n+// of the tests.\n+// TODO: Replace `assert(x == y)` back with `assert_eq(x, y)` once `assert_eq` no longer\n+// causes data-section explosion. See also: https://github.com/FuelLabs/sway/issues/7612\n+contract;\n+\n+use test_types::*;\n+\n+use std::hash::{Hash, sha256};\n+use std::storage::storage_vec::*;\n+\n+/// Default number of vector elements to use in tests.\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+const NUM_OF_ELEMENTS: u64 = 11;\n+\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+#[storage(read, write)]\n+fn assert_swap_impl<T>(\n+ slot_id_preimage: u64,\n+)\n+where\n+ T: Eq + TestInstance + AbiEncode,\n+{\n+ assert_non_zero_sized_type::<T>();\n+\n+ let vec: StorageKey<StorageVec<T>> = StorageKey::new(sha256(slot_id_preimage), 0, sha256(slot_id_preimage + 100));\n+\n+ let expected_values = T::instances(NUM_OF_ELEMENTS);\n+\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ vec.push(expected_values.get(i).unwrap());\n+ i += 1;\n+ }\n+\n+ // Swap the first and last elements.\n+ vec.swap(0, NUM_OF_ELEMENTS - 1);\n+ assert(expected_values.get(NUM_OF_ELEMENTS - 1) == vec.get(0).unwrap().try_read());\n+ assert(expected_values.get(0) == vec.get(NUM_OF_ELEMENTS - 1).unwrap().try_read());\n+ assert(NUM_OF_ELEMENTS == vec.len());\n+\n+ let mut i = 1;\n+ while i < NUM_OF_ELEMENTS - 1 {\n+ assert(expected_values.get(i) == vec.get(i).unwrap().try_read());\n+ i += 1;\n+ }\n+\n+ // Swap two middle elements and verify only those positions change.\n+ let middle_left = NUM_OF_ELEMENTS / 2 - 1;\n+ let middle_right = NUM_OF_ELEMENTS / 2 + 1;\n+ vec.swap(middle_left, middle_right);\n+\n+ assert(expected_values.get(middle_right) == vec.get(middle_left).unwrap().try_read());\n+ assert(expected_values.get(middle_left) == vec.get(middle_right).unwrap().try_read());\n+ assert(expected_values.get(NUM_OF_ELEMENTS - 1) == vec.get(0).unwrap().try_read());\n+ assert(expected_values.get(0) == vec.get(NUM_OF_ELEMENTS - 1).unwrap().try_read());\n+ assert(NUM_OF_ELEMENTS == vec.len());\n+\n+ let mut i = 1;\n+ while i < NUM_OF_ELEMENTS - 1 {\n+ if i != middle_left && i != middle_right {\n+ assert(expected_values.get(i) == vec.get(i).unwrap().try_read());\n+ }\n+ i += 1;\n+ }\n+\n+ // Swapping an element with itself is a no-op.\n+ let unchanged_index = NUM_OF_ELEMENTS / 2;\n+ let before = vec.get(unchanged_index).unwrap().try_read();\n+ vec.swap(unchanged_index, unchanged_index);\n+ assert(before == vec.get(unchanged_index).unwrap().try_read());\n+ assert(NUM_OF_ELEMENTS == vec.len());\n+}\n+\n+impl Contract {\n+ // Note that zero-sized types like, e.g., `()`, `[u64;0]`, or `EmptyStruct`,\n+ // by definition of the storage access semantics, cannot be stored in\n+ // a `StorageVec<T>`. If the `T` is zero-sized it must be an another\n+ // nested storage type, e.g., `StorageVec<StorageMap<u64, b256>>`.\n+ // So, in all the tests below, we don't have zero-sized types.\n+\n+ #[storage(read, write)]\n+ fn assert_swap() {\n+ assert_swap_impl::<bool>(1);\n+ assert_swap_impl::<u8>(2);\n+ assert_swap_impl::<u16>(3);\n+ assert_swap_impl::<u32>(4);\n+ assert_swap_impl::<u64>(5);\n+ assert_swap_impl::<u256>(6);\n+ assert_swap_impl::<b256>(7);\n+ assert_swap_impl::<raw_slice>(8);\n+ assert_swap_impl::<str>(9);\n+ assert_swap_impl::<str[2]>(10);\n+ assert_swap_impl::<str[5]>(11);\n+ assert_swap_impl::<str[6]>(12);\n+ assert_swap_impl::<str[8]>(13);\n+ assert_swap_impl::<str[12]>(14);\n+ assert_swap_impl::<str[13]>(15);\n+ assert_swap_impl::<[u64; 2]>(16);\n+ assert_swap_impl::<ArrayU8Len2>(17);\n+ assert_swap_impl::<ArrayU8Len5>(18);\n+ assert_swap_impl::<ArrayU8Len6>(19);\n+ assert_swap_impl::<ArrayU8Len8>(20);\n+ assert_swap_impl::<ArrayU8Len12>(21);\n+ assert_swap_impl::<ArrayU8Len13>(22);\n+ assert_swap_impl::<ArrayU64Len3>(23);\n+ assert_swap_impl::<ArrayNestedArrayU8Len2Len3>(24);\n+ assert_swap_impl::<ArrayStructBLen2>(25);\n+ assert_swap_impl::<RawPtrNewtype>(26);\n+ assert_swap_impl::<StructA>(27);\n+ assert_swap_impl::<StructB>(28);\n+ assert_swap_impl::<EnumSingleU8>(29);\n+ assert_swap_impl::<EnumSingleU64>(30);\n+ assert_swap_impl::<EnumSingleBool>(31);\n+ assert_swap_impl::<EnumMultiUnits>(32);\n+ assert_swap_impl::<EnumMultiOneByte>(33);\n+ assert_swap_impl::<EnumU8AndU64>(34);\n+ assert_swap_impl::<EnumQuadSlotSize>(35);\n+ assert_swap_impl::<EnumLargerThanQuadSlot>(36);\n+ assert_swap_impl::<(u8, u32)>(37);\n+ }\n+\n+ #[storage(write)]\n+ fn assert_swap_index_out_of_bounds() {\n+ let vec: StorageKey<StorageVec<u64>> = StorageKey::new(b256::zero(), 0, b256::zero());\n+ vec.swap(0, 1);\n+ }\n+\n+ #[storage(write)]\n+ fn assert_swap_nested_storage_type() {\n+ let vec: StorageKey<StorageVec<StorageVec<u64>>> = StorageKey::new(b256::zero(), 0, b256::zero());\n+ vec.push(StorageVec {});\n+ vec.push(StorageVec {});\n+ vec.swap(0, 1); // Nested storage types cannot be swapped.\n+ }\n+\n+}\n+\n+#[test]\n+fn swap() {\n+ let caller = abi(StorageVecSwapContractTestsAbi, CONTRACT_ID);\n+ caller.assert_swap();\n+}\n+\n+#[test(should_revert)]\n+fn swap_out_of_bounds() {\n+ let caller = abi(StorageVecSwapContractTestsAbi, CONTRACT_ID);\n+ caller.assert_swap_index_out_of_bounds();\n+}\n+\n+#[test(should_revert)]\n+fn swap_nested_storage_type() {\n+ let caller = abi(StorageVecSwapContractTestsAbi, CONTRACT_ID);\n+ caller.assert_swap_nested_storage_type();\n+}\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_swap_remove_contract_tests/Forc.toml b/test/src/in_language_tests/test_programs/storage_vec_swap_remove_contract_tests/Forc.toml\nnew file mode 100644\nindex 00000000000..683b9736cc4\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_vec_swap_remove_contract_tests/Forc.toml\n@@ -0,0 +1,9 @@\n+[project]\n+authors = [\"Fuel Labs <contact@fuel.sh>\"]\n+entry = \"main.sw\"\n+license = \"Apache-2.0\"\n+name = \"storage_vec_swap_remove_contract_tests\"\n+\n+[dependencies]\n+std = { path = \"../../../../../sway-lib-std\" }\n+test_types = { path = \"../test_types\" }\ndiff --git a/test/src/in_language_tests/test_programs/storage_vec_swap_remove_contract_tests/src/main.sw b/test/src/in_language_tests/test_programs/storage_vec_swap_remove_contract_tests/src/main.sw\nnew file mode 100644\nindex 00000000000..bba7b904beb\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_vec_swap_remove_contract_tests/src/main.sw\n@@ -0,0 +1,156 @@\n+// TODO: The initial reason for having several `storage_vec` tests is\n+// reaching the limit in the data section size of a single contract\n+// that contained all the tests for `StorageVec<T>` methods.\n+// See: https://github.com/FuelLabs/sway/issues/7612\n+// But even when the issue is solved, it perhaps still makes sense to have\n+// separate test projects for better organization and readability\n+// of the tests.\n+// TODO: Replace `assert(x == y)` back with `assert_eq(x, y)` once `assert_eq` no longer\n+// causes data-section explosion. See also: https://github.com/FuelLabs/sway/issues/7612\n+contract;\n+\n+use test_types::*;\n+\n+use std::hash::{Hash, sha256};\n+use std::storage::storage_vec::*;\n+\n+/// Default number of vector elements to use in tests.\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+const NUM_OF_ELEMENTS: u64 = 11;\n+\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+#[storage(read, write)]\n+fn assert_swap_remove_impl<T>(\n+ slot_id_preimage: u64,\n+)\n+where\n+ T: Eq + TestInstance + AbiEncode,\n+{\n+ assert_non_zero_sized_type::<T>();\n+\n+ let vec: StorageKey<StorageVec<T>> = StorageKey::new(sha256(slot_id_preimage), 0, sha256(slot_id_preimage + 100));\n+\n+ let expected_values = T::instances(NUM_OF_ELEMENTS);\n+\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ vec.push(expected_values.get(i).unwrap());\n+ i += 1;\n+ }\n+\n+ // Swap-remove front element: it should be replaced by the last, and length decremented.\n+ let removed_front = vec.swap_remove(0);\n+ assert(expected_values.get(0).unwrap() == removed_front);\n+ assert(NUM_OF_ELEMENTS - 1 == vec.len());\n+ // The last element (index NUM_OF_ELEMENTS - 1) should now be at index 0.\n+ assert(expected_values.get(NUM_OF_ELEMENTS - 1) == vec.get(0).unwrap().try_read());\n+ // All other elements (1..NUM_OF_ELEMENTS-1) remain at their original positions.\n+ let mut i = 1;\n+ while i < vec.len() {\n+ assert(expected_values.get(i) == vec.get(i).unwrap().try_read());\n+ i += 1;\n+ }\n+\n+ // Swap-remove middle element.\n+ let middle_index = vec.len() / 2;\n+ let removed_middle = vec.swap_remove(middle_index);\n+ assert(expected_values.get(middle_index).unwrap() == removed_middle);\n+ assert(NUM_OF_ELEMENTS - 2 == vec.len());\n+ // The element that was last before this removal (index NUM_OF_ELEMENTS - 2 of the prior state,\n+ // which is expected_values[NUM_OF_ELEMENTS - 2]) is now at middle_index.\n+ assert(expected_values.get(NUM_OF_ELEMENTS - 2) == vec.get(middle_index).unwrap().try_read());\n+\n+ // Swap-remove last element: it should simply be removed without any swap.\n+ let last_index = vec.len() - 1;\n+ let removed_last = vec.swap_remove(last_index);\n+ assert(expected_values.get(last_index).unwrap() == removed_last);\n+ assert(NUM_OF_ELEMENTS - 3 == vec.len());\n+\n+ // Swap-remove when there's only one element left: it should be removed and vector becomes empty.\n+ let _ = vec.clear();\n+ vec.push(expected_values.get(0).unwrap());\n+ let removed_only = vec.swap_remove(0);\n+ assert(expected_values.get(0).unwrap() == removed_only);\n+ assert(0 == vec.len());\n+}\n+\n+impl Contract {\n+ // Note that zero-sized types like, e.g., `()`, `[u64;0]`, or `EmptyStruct`,\n+ // by definition of the storage access semantics, cannot be stored in\n+ // a `StorageVec<T>`. If the `T` is zero-sized it must be an another\n+ // nested storage type, e.g., `StorageVec<StorageMap<u64, b256>>`.\n+ // So, in all the tests below, we don't have zero-sized types.\n+\n+ #[storage(read, write)]\n+ fn assert_swap_remove() {\n+ assert_swap_remove_impl::<bool>(1);\n+ assert_swap_remove_impl::<u8>(2);\n+ assert_swap_remove_impl::<u16>(3);\n+ assert_swap_remove_impl::<u32>(4);\n+ assert_swap_remove_impl::<u64>(5);\n+ assert_swap_remove_impl::<u256>(6);\n+ assert_swap_remove_impl::<b256>(7);\n+ assert_swap_remove_impl::<raw_slice>(8);\n+ assert_swap_remove_impl::<str>(9);\n+ assert_swap_remove_impl::<str[2]>(10);\n+ assert_swap_remove_impl::<str[5]>(11);\n+ assert_swap_remove_impl::<str[6]>(12);\n+ assert_swap_remove_impl::<str[8]>(13);\n+ assert_swap_remove_impl::<str[12]>(14);\n+ assert_swap_remove_impl::<str[13]>(15);\n+ assert_swap_remove_impl::<[u64; 2]>(16);\n+ assert_swap_remove_impl::<ArrayU8Len2>(17);\n+ assert_swap_remove_impl::<ArrayU8Len5>(18);\n+ assert_swap_remove_impl::<ArrayU8Len6>(19);\n+ assert_swap_remove_impl::<ArrayU8Len8>(20);\n+ assert_swap_remove_impl::<ArrayU8Len12>(21);\n+ assert_swap_remove_impl::<ArrayU8Len13>(22);\n+ assert_swap_remove_impl::<ArrayU64Len3>(23);\n+ assert_swap_remove_impl::<ArrayNestedArrayU8Len2Len3>(24);\n+ assert_swap_remove_impl::<ArrayStructBLen2>(25);\n+ assert_swap_remove_impl::<RawPtrNewtype>(26);\n+ assert_swap_remove_impl::<StructA>(27);\n+ assert_swap_remove_impl::<StructB>(28);\n+ assert_swap_remove_impl::<EnumSingleU8>(29);\n+ assert_swap_remove_impl::<EnumSingleU64>(30);\n+ assert_swap_remove_impl::<EnumSingleBool>(31);\n+ assert_swap_remove_impl::<EnumMultiUnits>(32);\n+ assert_swap_remove_impl::<EnumMultiOneByte>(33);\n+ assert_swap_remove_impl::<EnumU8AndU64>(34);\n+ assert_swap_remove_impl::<EnumQuadSlotSize>(35);\n+ assert_swap_remove_impl::<EnumLargerThanQuadSlot>(36);\n+ assert_swap_remove_impl::<(u8, u32)>(37);\n+ }\n+\n+ #[storage(read, write)]\n+ fn assert_swap_remove_index_out_of_bounds() {\n+ let vec: StorageKey<StorageVec<u64>> = StorageKey::new(b256::zero(), 0, b256::zero());\n+ let _ = vec.swap_remove(0);\n+ }\n+\n+ #[storage(write)]\n+ fn assert_swap_remove_nested_storage_type() {\n+ let vec: StorageKey<StorageVec<StorageVec<u64>>> = StorageKey::new(b256::zero(), 0, b256::zero());\n+ vec.push(StorageVec {});\n+ let _ = vec.swap_remove(0); // Nested storage types cannot be swap-removed.\n+ }\n+\n+}\n+\n+#[test]\n+fn swap_remove() {\n+ let caller = abi(StorageVecSwapRemoveContractTestsAbi, CONTRACT_ID);\n+ caller.assert_swap_remove();\n+}\n+\n+#[test(should_revert)]\n+fn swap_remove_out_of_bounds() {\n+ let caller = abi(StorageVecSwapRemoveContractTestsAbi, CONTRACT_ID);\n+ caller.assert_swap_remove_index_out_of_bounds();\n+}\n+\n+#[test(should_revert)]\n+fn swap_remove_nested_storage_type() {\n+ let caller = abi(StorageVecSwapRemoveContractTestsAbi, CONTRACT_ID);\n+ caller.assert_swap_remove_nested_storage_type();\n+}\ndiff --git a/test/src/sdk-harness/test_projects/storage_vec_to_vec/Forc.toml b/test/src/in_language_tests/test_programs/test_types/Forc.toml\nsimilarity index 84%\nrename from test/src/sdk-harness/test_projects/storage_vec_to_vec/Forc.toml\nrename to test/src/in_language_tests/test_programs/test_types/Forc.toml\nindex 0841b7ac887..223bb023933 100644\n--- a/test/src/sdk-harness/test_projects/storage_vec_to_vec/Forc.toml\n+++ b/test/src/in_language_tests/test_programs/test_types/Forc.toml\n@@ -2,7 +2,7 @@\n authors = [\"Fuel Labs <contact@fuel.sh>\"]\n entry = \"main.sw\"\n license = \"Apache-2.0\"\n-name = \"storage_vec_to_vec\"\n+name = \"test_types\"\n \n [dependencies]\n std = { path = \"../../../../../sway-lib-std\" }\ndiff --git a/test/src/in_language_tests/test_programs/test_types/src/main.sw b/test/src/in_language_tests/test_programs/test_types/src/main.sw\nnew file mode 100644\nindex 00000000000..a9e8e7fca45\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/test_types/src/main.sw\n@@ -0,0 +1,1057 @@\n+//! This library contains types and traits meant to be used\n+//! in tests that need to test functionality across different,\n+//! representative, Sway types.\n+library;\n+\n+use std::ops::Eq;\n+use std::flags::{disable_panic_on_overflow, enable_panic_on_overflow};\n+use std::raw_slice::*;\n+\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+pub fn assert_non_zero_sized_type<T>() {\n+ if __size_of::<T>() == 0 {\n+ panic \"Type must be a non-zero-sized type.\"\n+ }\n+}\n+\n+pub type ArrayU8Len2 = [u8; 2];\n+pub type ArrayU8Len5 = [u8; 5];\n+pub type ArrayU8Len6 = [u8; 6];\n+pub type ArrayU8Len8 = [u8; 8];\n+pub type ArrayU8Len12 = [u8; 12];\n+pub type ArrayU8Len13 = [u8; 13];\n+pub type ArrayU64Len3 = [u64; 3];\n+pub type ArrayNestedArrayU8Len2Len3 = [ArrayU8Len2; 3];\n+\n+pub trait TestInstance {\n+ /// Returns a default instance of `Self`.\n+ fn default() -> Self;\n+\n+ /// Returns a typical (non-zero, non-default-looking) instance of `Self`.\n+ /// Whenever possible, this is different from `default()`.\n+ fn typical_value() -> Self;\n+\n+ /// Returns a [Vec] of `count` quasi-random instances of `Self`.\n+ fn instances(count: u64) -> Vec<Self>;\n+} {\n+ /// Returns a [Vec] of `count` default instances of `Self`.\n+ fn default_instances(count: u64) -> Vec<Self> {\n+ let mut res = Vec::new();\n+ let mut i = 0;\n+ while i < count {\n+ res.push(Self::default());\n+ i += 1;\n+ }\n+ res\n+ }\n+}\n+\n+impl TestInstance for bool {\n+ fn default() -> Self {\n+ false\n+ }\n+\n+ fn typical_value() -> Self {\n+ true\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let mut res = Vec::new();\n+ let mut i = 0;\n+ while i < count {\n+ res.push(i % 3 == 0);\n+ i += 1;\n+ }\n+ res\n+ }\n+}\n+\n+impl TestInstance for u8 {\n+ fn default() -> Self {\n+ 0\n+ }\n+\n+ fn typical_value() -> Self {\n+ 42u8\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let mut res = Vec::new();\n+ res.push(1);\n+ res.push(2);\n+ let mut i = 2;\n+ let _ = disable_panic_on_overflow();\n+ while i < count {\n+ res.push(res.get(i - 1).unwrap() + res.get(i - 2).unwrap());\n+ i += 1;\n+ }\n+ enable_panic_on_overflow();\n+ res\n+ }\n+}\n+\n+impl TestInstance for u16 {\n+ fn default() -> Self {\n+ 0\n+ }\n+\n+ fn typical_value() -> Self {\n+ 42u16\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let mut res = Vec::new();\n+ res.push(1);\n+ res.push(2);\n+ let mut i = 2;\n+ let _ = disable_panic_on_overflow();\n+ while i < count {\n+ res.push(res.get(i - 1).unwrap() + res.get(i - 2).unwrap());\n+ i += 1;\n+ }\n+ enable_panic_on_overflow();\n+ res\n+ }\n+}\n+\n+impl TestInstance for u32 {\n+ fn default() -> Self {\n+ 0\n+ }\n+\n+ fn typical_value() -> Self {\n+ 42u32\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let mut res = Vec::new();\n+ res.push(1);\n+ res.push(2);\n+ let mut i = 2;\n+ let _ = disable_panic_on_overflow();\n+ while i < count {\n+ res.push(res.get(i - 1).unwrap() + res.get(i - 2).unwrap());\n+ i += 1;\n+ }\n+ enable_panic_on_overflow();\n+ res\n+ }\n+}\n+\n+impl TestInstance for u64 {\n+ fn default() -> Self {\n+ 0\n+ }\n+\n+ fn typical_value() -> Self {\n+ 42u64\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let mut res = Vec::new();\n+ res.push(1);\n+ res.push(2);\n+ let mut i = 2;\n+ let _ = disable_panic_on_overflow();\n+ while i < count {\n+ res.push(res.get(i - 1).unwrap() + res.get(i - 2).unwrap());\n+ i += 1;\n+ }\n+ enable_panic_on_overflow();\n+ res\n+ }\n+}\n+\n+impl TestInstance for u256 {\n+ fn default() -> Self {\n+ 0u256\n+ }\n+\n+ fn typical_value() -> Self {\n+ 0x2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2au256\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let mut res = Vec::new();\n+ res.push(0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20u256);\n+ let mut i = 1;\n+ while i < count {\n+ res.push(res.get(i - 1).unwrap() / i.into());\n+ i += 1;\n+ }\n+ res\n+ }\n+}\n+\n+impl TestInstance for str {\n+ fn default() -> Self {\n+ \"\"\n+ }\n+\n+ fn typical_value() -> Self {\n+ \"hello\"\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let mut res = Vec::new();\n+ let mut i = 0;\n+ while i < count {\n+ let string: str = match i % 3 {\n+ 0 => \"a1\",\n+ 1 => \"b2c3\",\n+ 2 => \"d4e5f6\",\n+ _ => \"unreachable\",\n+ };\n+ res.push(string);\n+ i += 1;\n+ }\n+ res\n+ }\n+}\n+\n+impl TestInstance for str[2] {\n+ fn default() -> Self {\n+ __to_str_array(\"..\")\n+ }\n+\n+ fn typical_value() -> Self {\n+ __to_str_array(\"42\")\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let mut res = Vec::new();\n+ let mut i = 0;\n+ while i < count {\n+ let string: str[2] = match i % 3 {\n+ 0 => __to_str_array(\"a1\"),\n+ 1 => __to_str_array(\"b2\"),\n+ 2 => __to_str_array(\"d4\"),\n+ _ => __to_str_array(\"..\"),\n+ };\n+ res.push(string);\n+ i += 1;\n+ }\n+ res\n+ }\n+}\n+\n+impl TestInstance for str[5] {\n+ fn default() -> Self {\n+ __to_str_array(\".....\")\n+ }\n+\n+ fn typical_value() -> Self {\n+ __to_str_array(\"hello\")\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let mut res = Vec::new();\n+ let mut i = 0;\n+ while i < count {\n+ let string: str[5] = match i % 3 {\n+ 0 => __to_str_array(\"a1a1a\"),\n+ 1 => __to_str_array(\"b2c3b\"),\n+ 2 => __to_str_array(\"d4e5f\"),\n+ _ => __to_str_array(\".....\"),\n+ };\n+ res.push(string);\n+ i += 1;\n+ }\n+ res\n+ }\n+}\n+\n+impl TestInstance for str[6] {\n+ fn default() -> Self {\n+ __to_str_array(\"......\")\n+ }\n+\n+ fn typical_value() -> Self {\n+ __to_str_array(\"fuel42\")\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let mut res = Vec::new();\n+ let mut i = 0;\n+ while i < count {\n+ let string: str[6] = match i % 3 {\n+ 0 => __to_str_array(\"a1a1a1\"),\n+ 1 => __to_str_array(\"b2c3b2\"),\n+ 2 => __to_str_array(\"d4e5f6\"),\n+ _ => __to_str_array(\"......\"),\n+ };\n+ res.push(string);\n+ i += 1;\n+ }\n+ res\n+ }\n+}\n+\n+impl TestInstance for str[8] {\n+ fn default() -> Self {\n+ __to_str_array(\"........\")\n+ }\n+\n+ fn typical_value() -> Self {\n+ __to_str_array(\"hello_42\")\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let mut res = Vec::new();\n+ let mut i = 0;\n+ while i < count {\n+ let string: str[8] = match i % 3 {\n+ 0 => __to_str_array(\"a1a1a1a1\"),\n+ 1 => __to_str_array(\"b2c3b2c3\"),\n+ 2 => __to_str_array(\"d4e5f6g7\"),\n+ _ => __to_str_array(\"........\"),\n+ };\n+ res.push(string);\n+ i += 1;\n+ }\n+ res\n+ }\n+}\n+\n+impl TestInstance for str[12] {\n+ fn default() -> Self {\n+ __to_str_array(\"............\")\n+ }\n+\n+ fn typical_value() -> Self {\n+ __to_str_array(\"hello_world!\")\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let mut res = Vec::new();\n+ let mut i = 0;\n+ while i < count {\n+ let string: str[12] = match i % 3 {\n+ 0 => __to_str_array(\"a1a1a1a1a1a1\"),\n+ 1 => __to_str_array(\"b2c3b2c3b2c3\"),\n+ 2 => __to_str_array(\"d4e5f6g7h8i9\"),\n+ _ => __to_str_array(\"............\"),\n+ };\n+ res.push(string);\n+ i += 1;\n+ }\n+ res\n+ }\n+}\n+\n+impl TestInstance for str[13] {\n+ fn default() -> Self {\n+ __to_str_array(\".............\")\n+ }\n+\n+ fn typical_value() -> Self {\n+ __to_str_array(\"hello_world42\")\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let mut res = Vec::new();\n+ let mut i = 0;\n+ while i < count {\n+ let string: str[13] = match i % 3 {\n+ 0 => __to_str_array(\"a1a1a1a1a1a1a\"),\n+ 1 => __to_str_array(\"b2c3b2c3b2c3b\"),\n+ 2 => __to_str_array(\"d4e5f6g7h8i9j\"),\n+ _ => __to_str_array(\".............\"),\n+ };\n+ res.push(string);\n+ i += 1;\n+ }\n+ res\n+ }\n+}\n+\n+impl<T, const N: u64> TestInstance for [T; N]\n+where\n+ T: TestInstance,\n+{\n+ fn default() -> Self {\n+ [T::default(); N]\n+ }\n+\n+ fn typical_value() -> Self {\n+ [T::typical_value(); N]\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let mut res = Vec::new();\n+ let instances = T::instances(count);\n+ let mut i = 0;\n+ while i < count {\n+ let mut array = [T::default(); N];\n+ let mut j = 0;\n+ while j < N {\n+ array[j] = instances.get(i).unwrap();\n+ j += 1;\n+ }\n+ res.push(array);\n+ i += 1;\n+ }\n+ res\n+ }\n+}\n+\n+pub struct EmptyStruct {}\n+\n+impl PartialEq for EmptyStruct {\n+ fn eq(self, other: Self) -> bool {\n+ true\n+ }\n+}\n+impl Eq for EmptyStruct {}\n+\n+impl TestInstance for EmptyStruct {\n+ fn default() -> Self {\n+ EmptyStruct {}\n+ }\n+\n+ fn typical_value() -> Self {\n+ EmptyStruct {} // Zero-sized type: only one possible value.\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let mut res = Vec::new();\n+ let mut i = 0;\n+ while i < count {\n+ res.push(EmptyStruct {});\n+ i += 1;\n+ }\n+ res\n+ }\n+}\n+\n+pub enum EnumSingleU8 {\n+ A: u8,\n+}\n+\n+impl PartialEq for EnumSingleU8 {\n+ fn eq(self, other: Self) -> bool {\n+ match (self, other) {\n+ (EnumSingleU8::A(l), EnumSingleU8::A(r)) => l == r,\n+ }\n+ }\n+}\n+impl Eq for EnumSingleU8 {}\n+\n+impl TestInstance for EnumSingleU8 {\n+ fn default() -> Self {\n+ EnumSingleU8::A(u8::default())\n+ }\n+\n+ fn typical_value() -> Self {\n+ EnumSingleU8::A(42u8)\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let values = u8::instances(count);\n+ let mut res = Vec::new();\n+ let mut i = 0;\n+ while i < count {\n+ res.push(EnumSingleU8::A(values.get(i).unwrap()));\n+ i += 1;\n+ }\n+ res\n+ }\n+}\n+\n+pub enum EnumSingleU64 {\n+ A: u64,\n+}\n+\n+impl PartialEq for EnumSingleU64 {\n+ fn eq(self, other: Self) -> bool {\n+ match (self, other) {\n+ (EnumSingleU64::A(l), EnumSingleU64::A(r)) => l == r,\n+ }\n+ }\n+}\n+impl Eq for EnumSingleU64 {}\n+\n+impl TestInstance for EnumSingleU64 {\n+ fn default() -> Self {\n+ EnumSingleU64::A(u64::default())\n+ }\n+\n+ fn typical_value() -> Self {\n+ EnumSingleU64::A(42u64)\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let values = u64::instances(count);\n+ let mut res = Vec::new();\n+ let mut i = 0;\n+ while i < count {\n+ res.push(EnumSingleU64::A(values.get(i).unwrap()));\n+ i += 1;\n+ }\n+ res\n+ }\n+}\n+\n+pub enum EnumSingleBool {\n+ A: bool,\n+}\n+\n+impl PartialEq for EnumSingleBool {\n+ fn eq(self, other: Self) -> bool {\n+ match (self, other) {\n+ (EnumSingleBool::A(l), EnumSingleBool::A(r)) => l == r,\n+ }\n+ }\n+}\n+impl Eq for EnumSingleBool {}\n+\n+impl TestInstance for EnumSingleBool {\n+ fn default() -> Self {\n+ EnumSingleBool::A(bool::default())\n+ }\n+\n+ fn typical_value() -> Self {\n+ EnumSingleBool::A(true)\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let values = bool::instances(count);\n+ let mut res = Vec::new();\n+ let mut i = 0;\n+ while i < count {\n+ res.push(EnumSingleBool::A(values.get(i).unwrap()));\n+ i += 1;\n+ }\n+ res\n+ }\n+}\n+\n+pub enum EnumMultiUnits {\n+ A: (),\n+ B: (),\n+ C: (),\n+}\n+\n+impl PartialEq for EnumMultiUnits {\n+ fn eq(self, other: Self) -> bool {\n+ match (self, other) {\n+ (EnumMultiUnits::A, EnumMultiUnits::A) => true,\n+ (EnumMultiUnits::B, EnumMultiUnits::B) => true,\n+ (EnumMultiUnits::C, EnumMultiUnits::C) => true,\n+ _ => false,\n+ }\n+ }\n+}\n+impl Eq for EnumMultiUnits {}\n+\n+impl TestInstance for EnumMultiUnits {\n+ fn default() -> Self {\n+ EnumMultiUnits::A\n+ }\n+\n+ fn typical_value() -> Self {\n+ EnumMultiUnits::B\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let mut res = Vec::new();\n+ let mut i = 0;\n+ while i < count {\n+ match i % 3 {\n+ 0 => res.push(EnumMultiUnits::A),\n+ 1 => res.push(EnumMultiUnits::B),\n+ _ => res.push(EnumMultiUnits::C),\n+ };\n+ i += 1;\n+ }\n+ res\n+ }\n+}\n+\n+pub enum EnumMultiOneByte {\n+ A: bool,\n+ B: u8,\n+ C: (),\n+}\n+\n+impl PartialEq for EnumMultiOneByte {\n+ fn eq(self, other: Self) -> bool {\n+ match (self, other) {\n+ (EnumMultiOneByte::A(l), EnumMultiOneByte::A(r)) => l == r,\n+ (EnumMultiOneByte::B(l), EnumMultiOneByte::B(r)) => l == r,\n+ (EnumMultiOneByte::C, EnumMultiOneByte::C) => true,\n+ _ => false,\n+ }\n+ }\n+}\n+impl Eq for EnumMultiOneByte {}\n+\n+impl TestInstance for EnumMultiOneByte {\n+ fn default() -> Self {\n+ EnumMultiOneByte::A(bool::default())\n+ }\n+\n+ fn typical_value() -> Self {\n+ EnumMultiOneByte::B(42u8)\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let bool_values = bool::instances(count);\n+ let u8_values = u8::instances(count);\n+ let mut res = Vec::new();\n+ let mut i = 0;\n+ while i < count {\n+ match i % 3 {\n+ 0 => res.push(EnumMultiOneByte::A(bool_values.get(i).unwrap())),\n+ 1 => res.push(EnumMultiOneByte::B(u8_values.get(i).unwrap())),\n+ _ => res.push(EnumMultiOneByte::C),\n+ };\n+ i += 1;\n+ }\n+ res\n+ }\n+}\n+\n+pub enum EnumU8AndU64 {\n+ A: u8,\n+ B: u64,\n+}\n+\n+impl PartialEq for EnumU8AndU64 {\n+ fn eq(self, other: Self) -> bool {\n+ match (self, other) {\n+ (EnumU8AndU64::A(l), EnumU8AndU64::A(r)) => l == r,\n+ (EnumU8AndU64::B(l), EnumU8AndU64::B(r)) => l == r,\n+ _ => false,\n+ }\n+ }\n+}\n+impl Eq for EnumU8AndU64 {}\n+\n+impl TestInstance for EnumU8AndU64 {\n+ fn default() -> Self {\n+ EnumU8AndU64::A(u8::default())\n+ }\n+\n+ fn typical_value() -> Self {\n+ EnumU8AndU64::B(42u64)\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let u8_values = u8::instances(count);\n+ let u64_values = u64::instances(count);\n+ let mut res = Vec::new();\n+ let mut i = 0;\n+ while i < count {\n+ match i % 2 {\n+ 0 => res.push(EnumU8AndU64::A(u8_values.get(i).unwrap())),\n+ _ => res.push(EnumU8AndU64::B(u64_values.get(i).unwrap())),\n+ };\n+ i += 1;\n+ }\n+ res\n+ }\n+}\n+\n+pub enum EnumQuadSlotSize {\n+ A: u8,\n+ B: (u64, u64, u64),\n+}\n+\n+impl PartialEq for EnumQuadSlotSize {\n+ fn eq(self, other: Self) -> bool {\n+ match (self, other) {\n+ (EnumQuadSlotSize::A(l), EnumQuadSlotSize::A(r)) => l == r,\n+ (EnumQuadSlotSize::B(l), EnumQuadSlotSize::B(r)) => {\n+ l.0 == r.0 && l.1 == r.1 && l.2 == r.2\n+ }\n+ _ => false,\n+ }\n+ }\n+}\n+impl Eq for EnumQuadSlotSize {}\n+\n+impl TestInstance for EnumQuadSlotSize {\n+ fn default() -> Self {\n+ EnumQuadSlotSize::A(u8::default())\n+ }\n+\n+ fn typical_value() -> Self {\n+ EnumQuadSlotSize::B((42u64, 43u64, 44u64))\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let u8_values = u8::instances(count);\n+ let u64_values = u64::instances(count);\n+ let mut res = Vec::new();\n+ let mut i = 0;\n+ while i < count {\n+ match i % 2 {\n+ 0 => res.push(EnumQuadSlotSize::A(u8_values.get(i).unwrap())),\n+ _ => res.push(EnumQuadSlotSize::B((\n+ u64_values.get(i).unwrap(),\n+ u64_values.get((i + 1) % count).unwrap(),\n+ u64_values.get((i + 2) % count).unwrap(),\n+ ))),\n+ };\n+ i += 1;\n+ }\n+ res\n+ }\n+}\n+\n+pub enum EnumLargerThanQuadSlot {\n+ A: u8,\n+ B: (u64, u64, u64, u64, u64),\n+}\n+\n+impl PartialEq for EnumLargerThanQuadSlot {\n+ fn eq(self, other: Self) -> bool {\n+ match (self, other) {\n+ (EnumLargerThanQuadSlot::A(l), EnumLargerThanQuadSlot::A(r)) => l == r,\n+ (EnumLargerThanQuadSlot::B(l), EnumLargerThanQuadSlot::B(r)) => {\n+ l.0 == r.0 && l.1 == r.1 && l.2 == r.2 && l.3 == r.3 && l.4 == r.4\n+ }\n+ _ => false,\n+ }\n+ }\n+}\n+impl Eq for EnumLargerThanQuadSlot {}\n+\n+impl TestInstance for EnumLargerThanQuadSlot {\n+ fn default() -> Self {\n+ EnumLargerThanQuadSlot::A(u8::default())\n+ }\n+\n+ fn typical_value() -> Self {\n+ EnumLargerThanQuadSlot::B((42u64, 43u64, 44u64, 45u64, 46u64))\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let u8_values = u8::instances(count);\n+ let u64_values = u64::instances(count);\n+ let mut res = Vec::new();\n+ let mut i = 0;\n+ while i < count {\n+ match i % 2 {\n+ 0 => res.push(EnumLargerThanQuadSlot::A(u8_values.get(i).unwrap())),\n+ _ => res.push(EnumLargerThanQuadSlot::B((\n+ u64_values.get(i).unwrap(),\n+ u64_values.get((i + 1) % count).unwrap(),\n+ u64_values.get((i + 2) % count).unwrap(),\n+ u64_values.get((i + 3) % count).unwrap(),\n+ u64_values.get((i + 4) % count).unwrap(),\n+ ))),\n+ };\n+ i += 1;\n+ }\n+ res\n+ }\n+}\n+\n+pub struct StructA {\n+ f_bool: bool,\n+ f_u8: u8,\n+ f_u16: u16,\n+ f_u32: u32,\n+ f_u64: u64,\n+ f_u256: u256,\n+}\n+\n+impl PartialEq for StructA {\n+ fn eq(self, other: Self) -> bool {\n+ self.f_bool == other.f_bool\n+ && self.f_u8 == other.f_u8\n+ && self.f_u16 == other.f_u16\n+ && self.f_u32 == other.f_u32\n+ && self.f_u64 == other.f_u64\n+ && self.f_u256 == other.f_u256\n+ }\n+}\n+impl Eq for StructA {}\n+\n+impl TestInstance for StructA {\n+ fn default() -> Self {\n+ StructA {\n+ f_bool: bool::default(),\n+ f_u8: u8::default(),\n+ f_u16: u16::default(),\n+ f_u32: u32::default(),\n+ f_u64: u64::default(),\n+ f_u256: u256::default(),\n+ }\n+ }\n+\n+ fn typical_value() -> Self {\n+ StructA {\n+ f_bool: bool::typical_value(),\n+ f_u8: u8::typical_value(),\n+ f_u16: u16::typical_value(),\n+ f_u32: u32::typical_value(),\n+ f_u64: u64::typical_value(),\n+ f_u256: u256::typical_value(),\n+ }\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let bool_values = bool::instances(count);\n+ let u8_values = u8::instances(count);\n+ let u16_values = u16::instances(count);\n+ let u32_values = u32::instances(count);\n+ let u64_values = u64::instances(count);\n+ let u256_values = u256::instances(count);\n+\n+ let mut res = Vec::new();\n+ let mut i = 0;\n+ while i < count {\n+ res.push(StructA {\n+ f_bool: bool_values.get(i).unwrap(),\n+ f_u8: u8_values.get(i).unwrap(),\n+ f_u16: u16_values.get(i).unwrap(),\n+ f_u32: u32_values.get(i).unwrap(),\n+ f_u64: u64_values.get(i).unwrap(),\n+ f_u256: u256_values.get(i).unwrap(),\n+ });\n+ i += 1;\n+ }\n+ res\n+ }\n+}\n+\n+pub struct StructB {\n+ f_struct_a: StructA,\n+ f_tuple: (u8, u16, u32, u64, u256),\n+ // TODO: Uncomment below fields once\n+ // https://github.com/FuelLabs/sway/issues/7616 is resolved.\n+ // f_array_u8_len_2: ArrayU8Len2,\n+ // f_array_nested_array_u8_len_2_len_3: ArrayNestedArrayU8Len2Len3,\n+ f_array_u8_len_2: [u8; 2],\n+ f_array_nested_array_u8_len_2_len_3: [[u8; 2]; 3],\n+}\n+\n+pub type ArrayStructBLen2 = [StructB; 2];\n+\n+impl PartialEq for StructB {\n+ fn eq(self, other: Self) -> bool {\n+ self.f_struct_a == other.f_struct_a\n+ && self.f_tuple.0 == other.f_tuple.0\n+ && self.f_tuple.1 == other.f_tuple.1\n+ && self.f_tuple.2 == other.f_tuple.2\n+ && self.f_tuple.3 == other.f_tuple.3\n+ && self.f_tuple.4 == other.f_tuple.4\n+ && self.f_array_u8_len_2 == other.f_array_u8_len_2\n+ && self.f_array_nested_array_u8_len_2_len_3\n+ == other.f_array_nested_array_u8_len_2_len_3\n+ }\n+}\n+impl Eq for StructB {}\n+\n+impl TestInstance for StructB {\n+ fn default() -> Self {\n+ StructB {\n+ f_struct_a: StructA::default(),\n+ f_tuple: (\n+ u8::default(),\n+ u16::default(),\n+ u32::default(),\n+ u64::default(),\n+ u256::default(),\n+ ),\n+ // TODO: Uncomment below fields and their related code once\n+ // https://github.com/FuelLabs/sway/issues/7616 is resolved.\n+ // f_array_u8_len_2: ArrayU8Len2::default(count),\n+ // f_array_nested_array_u8_len_2_len_3: ArrayNestedArrayU8Len2Len3::default(count),\n+ f_array_u8_len_2: [u8::default(); 2],\n+ f_array_nested_array_u8_len_2_len_3: [[u8::default(); 2]; 3],\n+ }\n+ }\n+\n+ fn typical_value() -> Self {\n+ StructB {\n+ f_struct_a: StructA::typical_value(),\n+ f_tuple: (\n+ u8::typical_value(),\n+ u16::typical_value(),\n+ u32::typical_value(),\n+ u64::typical_value(),\n+ u256::typical_value(),\n+ ),\n+ f_array_u8_len_2: [u8::typical_value(); 2],\n+ f_array_nested_array_u8_len_2_len_3: [[u8::typical_value(); 2]; 3],\n+ }\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let struct_a_values = StructA::instances(count);\n+ let u8_values = u8::instances(count);\n+ let u16_values = u16::instances(count);\n+ let u32_values = u32::instances(count);\n+ let u64_values = u64::instances(count);\n+ let u256_values = u256::instances(count);\n+ // TODO: Uncomment below code\n+ // https://github.com/FuelLabs/sway/issues/7616 is resolved.\n+ // let array_u8_len_2_values = ArrayU8Len2::instances(count);\n+ // let array_nested_array_u8_len_2_len_3_values = ArrayNestedArrayU8Len2Len3::instances(count);\n+\n+ let mut res = Vec::new();\n+ let mut i = 0;\n+ while i < count {\n+ res.push(StructB {\n+ f_struct_a: struct_a_values.get(i).unwrap(),\n+ f_tuple: (\n+ u8_values.get(i).unwrap(),\n+ u16_values.get(i).unwrap(),\n+ u32_values.get(i).unwrap(),\n+ u64_values.get(i).unwrap(),\n+ u256_values.get(i).unwrap(),\n+ ),\n+ f_array_u8_len_2: [u8_values.get(i).unwrap(); 2],\n+ f_array_nested_array_u8_len_2_len_3: [[u8_values.get(i).unwrap(); 2]; 3],\n+ // TODO: Uncomment below code\n+ // https://github.com/FuelLabs/sway/issues/7616 is resolved.\n+ // f_array_u8_len_2: array_u8_len_2_values.get(i).unwrap(),\n+ // f_array_nested_array_u8_len_2_len_3:\n+ // array_nested_array_u8_len_2_len_3_values.get(i).unwrap(),\n+ });\n+ i += 1;\n+ }\n+ res\n+ }\n+}\n+\n+impl TestInstance for (u8, u32) {\n+ fn default() -> Self {\n+ (u8::default(), u32::default())\n+ }\n+\n+ fn typical_value() -> Self {\n+ (42u8, 42u32)\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let u8_values = u8::instances(count);\n+ let u32_values = u32::instances(count);\n+ let mut res = Vec::new();\n+ let mut i = 0;\n+ while i < count {\n+ res.push((u8_values.get(i).unwrap(), u32_values.get(i).unwrap()));\n+ i += 1;\n+ }\n+ res\n+ }\n+}\n+\n+impl TestInstance for b256 {\n+ fn default() -> Self {\n+ 0u256.as_b256()\n+ }\n+\n+ fn typical_value() -> Self {\n+ 0x2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2au256.as_b256()\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let mut res = Vec::new();\n+ res.push(\n+ 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20u256\n+ .as_b256(),\n+ );\n+ let mut i = 1;\n+ while i < count {\n+ res.push((res.get(i - 1).unwrap().as_u256() / i.into()).as_b256());\n+ i += 1;\n+ }\n+ res\n+ }\n+}\n+\n+pub struct RawPtrNewtype {\n+ ptr: raw_ptr,\n+}\n+\n+impl TestInstance for RawPtrNewtype {\n+ fn default() -> Self {\n+ let null_ptr = asm() {\n+ zero: raw_ptr\n+ };\n+ RawPtrNewtype { ptr: null_ptr }\n+ }\n+\n+ fn typical_value() -> Self {\n+ let null_ptr = asm() {\n+ zero: raw_ptr\n+ };\n+ RawPtrNewtype { ptr: null_ptr.add::<u8>(42) }\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let values = u8::instances(count);\n+ let mut res = Vec::new();\n+ let mut i = 0;\n+ while i < count {\n+ let null_ptr = asm() {\n+ zero: raw_ptr\n+ };\n+ res.push(RawPtrNewtype {\n+ ptr: null_ptr.add::<u64>(values.get(i).unwrap().as_u64())\n+ });\n+ i += 1;\n+ }\n+ res\n+ }\n+}\n+\n+impl AbiEncode for RawPtrNewtype {\n+ fn is_encode_trivial() -> bool { false }\n+ fn abi_encode(self, buffer: Buffer) -> Buffer {\n+ let ptr_as_u64 = asm(p: self.ptr) {\n+ p: u64\n+ };\n+ ptr_as_u64.abi_encode(buffer)\n+ }\n+}\n+\n+impl PartialEq for RawPtrNewtype {\n+ fn eq(self, other: Self) -> bool {\n+ self.ptr == other.ptr\n+ }\n+}\n+impl Eq for RawPtrNewtype {}\n+\n+impl TestInstance for raw_slice {\n+ fn default() -> Self {\n+ raw_slice::from_parts::<u64>(RawPtrNewtype::default().ptr, 0)\n+ }\n+\n+ fn typical_value() -> Self {\n+ let null_ptr = asm() {\n+ zero: raw_ptr\n+ };\n+ raw_slice::from_parts::<u8>(null_ptr, 42)\n+ }\n+\n+ fn instances(count: u64) -> Vec<Self> {\n+ let raw_ptr_values = RawPtrNewtype::instances(count);\n+ let mut ptr_values = Vec::<raw_ptr>::new();\n+ for raw_ptr in raw_ptr_values.iter() {\n+ ptr_values.push(raw_ptr.ptr);\n+ }\n+\n+ let len_values = u8::instances(count);\n+ let mut res = Vec::new();\n+ let mut i = 0;\n+ while i < count {\n+ res.push(raw_slice::from_parts::<u64>(\n+ ptr_values\n+ .get(i)\n+ .unwrap(),\n+ len_values\n+ .get(i)\n+ .unwrap()\n+ .as_u64()\n+ ));\n+ i += 1;\n+ }\n+ res\n+ }\n+}\ndiff --git a/test/src/sdk-harness/Forc.lock b/test/src/sdk-harness/Forc.lock\nindex 10e1cfef5ce..04e6c355a59 100644\n--- a/test/src/sdk-harness/Forc.lock\n+++ b/test/src/sdk-harness/Forc.lock\n@@ -321,6 +321,11 @@ name = \"storage_string\"\n source = \"member\"\n dependencies = [\"std\"]\n \n+[[package]]\n+name = \"storage_vec_of_storage_string\"\n+source = \"member\"\n+dependencies = [\"std\"]\n+\n [[package]]\n name = \"string_slice_predicate\"\n source = \"member\"\ndiff --git a/test/src/sdk-harness/Forc.toml b/test/src/sdk-harness/Forc.toml\nindex 1b2f0e9b4a6..7d74f800d25 100644\n--- a/test/src/sdk-harness/Forc.toml\n+++ b/test/src/sdk-harness/Forc.toml\n@@ -41,10 +41,7 @@ members = [\n \"test_projects/storage_map\",\n \"test_projects/storage_map_nested\",\n \"test_projects/storage_string\",\n- # TODO: (STORAGE-VEC) Uncomment once `StorageVec` is implemented for dynamic storage.\n- # \"test_projects/storage_vec_nested\",\n- # \"test_projects/storage_vec_of_storage_string\",\n- # \"test_projects/storage_vec_to_vec\",\n+ \"test_projects/storage_vec_of_storage_string\",\n \"test_projects/superabi\",\n \"test_projects/superabi_supertrait\",\n \"test_projects/time\",\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_array/Forc.lock b/test/src/sdk-harness/test_artifacts/storage_vec/svec_array/Forc.lock\ndeleted file mode 100644\nindex fb657189287..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_array/Forc.lock\n+++ /dev/null\n@@ -1,13 +0,0 @@\n-[[package]]\n-name = 'core'\n-source = 'path+from-root-F1A9B05C249770CB'\n-\n-[[package]]\n-name = 'std'\n-source = 'path+from-root-F1A9B05C249770CB'\n-dependencies = ['core']\n-\n-[[package]]\n-name = 'svec_array'\n-source = 'member'\n-dependencies = ['std']\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_array/Forc.toml b/test/src/sdk-harness/test_artifacts/storage_vec/svec_array/Forc.toml\ndeleted file mode 100644\nindex d95e0798fd4..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_array/Forc.toml\n+++ /dev/null\n@@ -1,8 +0,0 @@\n-[project]\n-authors = [\"Fuel Labs <contact@fuel.sh>\"]\n-entry = \"main.sw\"\n-license = \"Apache-2.0\"\n-name = \"svec_array\"\n-\n-[dependencies]\n-std = { path = \"../../../../../../sway-lib-std\" }\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_array/src/main.sw b/test/src/sdk-harness/test_artifacts/storage_vec/svec_array/src/main.sw\ndeleted file mode 100644\nindex a387998388d..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_array/src/main.sw\n+++ /dev/null\n@@ -1,139 +0,0 @@\n-contract;\n-\n-use std::storage::storage_vec::*;\n-\n-abi MyContract {\n- #[storage(read, write)]\n- fn push(value: [u8; 3]);\n-\n- #[storage(read, write)]\n- fn pop() -> [u8; 3];\n-\n- #[storage(read)]\n- fn get(index: u64) -> [u8; 3];\n-\n- #[storage(read, write)]\n- fn remove(index: u64) -> [u8; 3];\n-\n- #[storage(read, write)]\n- fn swap_remove(index: u64) -> [u8; 3];\n-\n- #[storage(read, write)]\n- fn set(index: u64, value: [u8; 3]);\n-\n- #[storage(read, write)]\n- fn insert(index: u64, value: [u8; 3]);\n-\n- #[storage(read)]\n- fn len() -> u64;\n-\n- #[storage(read)]\n- fn is_empty() -> bool;\n-\n- #[storage(write)]\n- fn clear();\n-\n- #[storage(read, write)]\n- fn swap(index_0: u64, index_1: u64);\n-\n- #[storage(read)]\n- fn first() -> [u8; 3];\n-\n- #[storage(read)]\n- fn last() -> [u8; 3];\n-\n- #[storage(read, write)]\n- fn reverse();\n-\n- #[storage(read, write)]\n- fn fill(value: [u8; 3]);\n-\n- #[storage(read, write)]\n- fn resize(new_len: u64, value: [u8; 3]);\n-}\n-\n-storage {\n- my_vec: StorageVec<[u8; 3]> = StorageVec {},\n-}\n-\n-impl MyContract for Contract {\n- #[storage(read, write)]\n- fn push(value: [u8; 3]) {\n- storage.my_vec.push(value);\n- }\n-\n- #[storage(read, write)]\n- fn pop() -> [u8; 3] {\n- storage.my_vec.pop().unwrap()\n- }\n-\n- #[storage(read)]\n- fn get(index: u64) -> [u8; 3] {\n- storage.my_vec.get(index).unwrap().read()\n- }\n-\n- #[storage(read, write)]\n- fn remove(index: u64) -> [u8; 3] {\n- storage.my_vec.remove(index)\n- }\n-\n- #[storage(read, write)]\n- fn swap_remove(index: u64) -> [u8; 3] {\n- storage.my_vec.swap_remove(index)\n- }\n-\n- #[storage(read, write)]\n- fn set(index: u64, value: [u8; 3]) {\n- storage.my_vec.set(index, value);\n- }\n-\n- #[storage(read, write)]\n- fn insert(index: u64, value: [u8; 3]) {\n- storage.my_vec.insert(index, value);\n- }\n-\n- #[storage(read)]\n- fn len() -> u64 {\n- storage.my_vec.len()\n- }\n-\n- #[storage(read)]\n- fn is_empty() -> bool {\n- storage.my_vec.is_empty()\n- }\n-\n- #[storage(write)]\n- fn clear() {\n- let _ = storage.my_vec.clear();\n- }\n-\n- #[storage(read, write)]\n- fn swap(index_0: u64, index_1: u64) {\n- storage.my_vec.swap(index_0, index_1);\n- }\n-\n- #[storage(read)]\n- fn first() -> [u8; 3] {\n- storage.my_vec.first().unwrap().read()\n- }\n-\n- #[storage(read)]\n- fn last() -> [u8; 3] {\n- storage.my_vec.last().unwrap().read()\n- }\n-\n- #[storage(read, write)]\n- fn reverse() {\n- storage.my_vec.reverse();\n- }\n-\n- #[storage(read, write)]\n- fn fill(value: [u8; 3]) {\n- storage.my_vec.fill(value);\n- }\n-\n- #[storage(read, write)]\n- fn resize(new_len: u64, value: [u8; 3]) {\n- storage.my_vec.resize(new_len, value);\n- }\n-}\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_b256/Forc.lock b/test/src/sdk-harness/test_artifacts/storage_vec/svec_b256/Forc.lock\ndeleted file mode 100644\nindex 4e468c574af..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_b256/Forc.lock\n+++ /dev/null\n@@ -1,13 +0,0 @@\n-[[package]]\n-name = 'core'\n-source = 'path+from-root-BAD4826C86E6CE3D'\n-\n-[[package]]\n-name = 'std'\n-source = 'path+from-root-BAD4826C86E6CE3D'\n-dependencies = ['core']\n-\n-[[package]]\n-name = 'svec_b256'\n-source = 'member'\n-dependencies = ['std']\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_b256/Forc.toml b/test/src/sdk-harness/test_artifacts/storage_vec/svec_b256/Forc.toml\ndeleted file mode 100644\nindex 1b1da6edb36..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_b256/Forc.toml\n+++ /dev/null\n@@ -1,8 +0,0 @@\n-[project]\n-authors = [\"Fuel Labs <contact@fuel.sh>\"]\n-entry = \"main.sw\"\n-license = \"Apache-2.0\"\n-name = \"svec_b256\"\n-\n-[dependencies]\n-std = { path = \"../../../../../../sway-lib-std\" }\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_b256/src/main.sw b/test/src/sdk-harness/test_artifacts/storage_vec/svec_b256/src/main.sw\ndeleted file mode 100644\nindex 029be33c48c..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_b256/src/main.sw\n+++ /dev/null\n@@ -1,139 +0,0 @@\n-contract;\n-\n-use std::storage::storage_vec::*;\n-\n-abi MyContract {\n- #[storage(read, write)]\n- fn push(value: b256);\n-\n- #[storage(read, write)]\n- fn pop() -> b256;\n-\n- #[storage(read)]\n- fn get(index: u64) -> b256;\n-\n- #[storage(read, write)]\n- fn remove(index: u64) -> b256;\n-\n- #[storage(read, write)]\n- fn swap_remove(index: u64) -> b256;\n-\n- #[storage(read, write)]\n- fn set(index: u64, value: b256);\n-\n- #[storage(read, write)]\n- fn insert(index: u64, value: b256);\n-\n- #[storage(read)]\n- fn len() -> u64;\n-\n- #[storage(read)]\n- fn is_empty() -> bool;\n-\n- #[storage(write)]\n- fn clear();\n-\n- #[storage(read, write)]\n- fn swap(index_0: u64, index_1: u64);\n-\n- #[storage(read)]\n- fn first() -> b256;\n-\n- #[storage(read)]\n- fn last() -> b256;\n-\n- #[storage(read, write)]\n- fn reverse();\n-\n- #[storage(read, write)]\n- fn fill(value: b256);\n-\n- #[storage(read, write)]\n- fn resize(new_len: u64, value: b256);\n-}\n-\n-storage {\n- my_vec: StorageVec<b256> = StorageVec {},\n-}\n-\n-impl MyContract for Contract {\n- #[storage(read, write)]\n- fn push(value: b256) {\n- storage.my_vec.push(value);\n- }\n-\n- #[storage(read, write)]\n- fn pop() -> b256 {\n- storage.my_vec.pop().unwrap()\n- }\n-\n- #[storage(read)]\n- fn get(index: u64) -> b256 {\n- storage.my_vec.get(index).unwrap().read()\n- }\n-\n- #[storage(read, write)]\n- fn remove(index: u64) -> b256 {\n- storage.my_vec.remove(index)\n- }\n-\n- #[storage(read, write)]\n- fn swap_remove(index: u64) -> b256 {\n- storage.my_vec.swap_remove(index)\n- }\n-\n- #[storage(read, write)]\n- fn set(index: u64, value: b256) {\n- storage.my_vec.set(index, value);\n- }\n-\n- #[storage(read, write)]\n- fn insert(index: u64, value: b256) {\n- storage.my_vec.insert(index, value);\n- }\n-\n- #[storage(read)]\n- fn len() -> u64 {\n- storage.my_vec.len()\n- }\n-\n- #[storage(read)]\n- fn is_empty() -> bool {\n- storage.my_vec.is_empty()\n- }\n-\n- #[storage(write)]\n- fn clear() {\n- let _ = storage.my_vec.clear();\n- }\n-\n- #[storage(read, write)]\n- fn swap(index_0: u64, index_1: u64) {\n- storage.my_vec.swap(index_0, index_1);\n- }\n-\n- #[storage(read)]\n- fn first() -> b256 {\n- storage.my_vec.first().unwrap().read()\n- }\n-\n- #[storage(read)]\n- fn last() -> b256 {\n- storage.my_vec.last().unwrap().read()\n- }\n-\n- #[storage(read, write)]\n- fn reverse() {\n- storage.my_vec.reverse();\n- }\n-\n- #[storage(read, write)]\n- fn fill(value: b256) {\n- storage.my_vec.fill(value);\n- }\n-\n- #[storage(read, write)]\n- fn resize(new_len: u64, value: b256) {\n- storage.my_vec.resize(new_len, value);\n- }\n-}\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_bool/Forc.lock b/test/src/sdk-harness/test_artifacts/storage_vec/svec_bool/Forc.lock\ndeleted file mode 100644\nindex 4fd1b9a9c90..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_bool/Forc.lock\n+++ /dev/null\n@@ -1,13 +0,0 @@\n-[[package]]\n-name = 'core'\n-source = 'path+from-root-112F6FFCFCECE066'\n-\n-[[package]]\n-name = 'std'\n-source = 'path+from-root-112F6FFCFCECE066'\n-dependencies = ['core']\n-\n-[[package]]\n-name = 'svec_bool'\n-source = 'member'\n-dependencies = ['std']\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_bool/Forc.toml b/test/src/sdk-harness/test_artifacts/storage_vec/svec_bool/Forc.toml\ndeleted file mode 100644\nindex e7681654fa1..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_bool/Forc.toml\n+++ /dev/null\n@@ -1,8 +0,0 @@\n-[project]\n-authors = [\"Fuel Labs <contact@fuel.sh>\"]\n-entry = \"main.sw\"\n-license = \"Apache-2.0\"\n-name = \"svec_bool\"\n-\n-[dependencies]\n-std = { path = \"../../../../../../sway-lib-std\" }\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_bool/src/main.sw b/test/src/sdk-harness/test_artifacts/storage_vec/svec_bool/src/main.sw\ndeleted file mode 100644\nindex dafaed1feb5..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_bool/src/main.sw\n+++ /dev/null\n@@ -1,139 +0,0 @@\n-contract;\n-\n-use std::storage::storage_vec::*;\n-\n-abi MyContract {\n- #[storage(read, write)]\n- fn push(value: bool);\n-\n- #[storage(read, write)]\n- fn pop() -> bool;\n-\n- #[storage(read)]\n- fn get(index: u64) -> bool;\n-\n- #[storage(read, write)]\n- fn remove(index: u64) -> bool;\n-\n- #[storage(read, write)]\n- fn swap_remove(index: u64) -> bool;\n-\n- #[storage(read, write)]\n- fn set(index: u64, value: bool);\n-\n- #[storage(read, write)]\n- fn insert(index: u64, value: bool);\n-\n- #[storage(read)]\n- fn len() -> u64;\n-\n- #[storage(read)]\n- fn is_empty() -> bool;\n-\n- #[storage(write)]\n- fn clear();\n-\n- #[storage(read, write)]\n- fn swap(index_0: u64, index_1: u64);\n-\n- #[storage(read)]\n- fn first() -> bool;\n-\n- #[storage(read)]\n- fn last() -> bool;\n-\n- #[storage(read, write)]\n- fn reverse();\n-\n- #[storage(read, write)]\n- fn fill(value: bool);\n-\n- #[storage(read, write)]\n- fn resize(new_len: u64, value: bool);\n-}\n-\n-storage {\n- my_vec: StorageVec<bool> = StorageVec {},\n-}\n-\n-impl MyContract for Contract {\n- #[storage(read, write)]\n- fn push(value: bool) {\n- storage.my_vec.push(value);\n- }\n-\n- #[storage(read, write)]\n- fn pop() -> bool {\n- storage.my_vec.pop().unwrap()\n- }\n-\n- #[storage(read)]\n- fn get(index: u64) -> bool {\n- storage.my_vec.get(index).unwrap().read()\n- }\n-\n- #[storage(read, write)]\n- fn remove(index: u64) -> bool {\n- storage.my_vec.remove(index)\n- }\n-\n- #[storage(read, write)]\n- fn swap_remove(index: u64) -> bool {\n- storage.my_vec.swap_remove(index)\n- }\n-\n- #[storage(read, write)]\n- fn set(index: u64, value: bool) {\n- storage.my_vec.set(index, value);\n- }\n-\n- #[storage(read, write)]\n- fn insert(index: u64, value: bool) {\n- storage.my_vec.insert(index, value);\n- }\n-\n- #[storage(read)]\n- fn len() -> u64 {\n- storage.my_vec.len()\n- }\n-\n- #[storage(read)]\n- fn is_empty() -> bool {\n- storage.my_vec.is_empty()\n- }\n-\n- #[storage(write)]\n- fn clear() {\n- let _ = storage.my_vec.clear();\n- }\n-\n- #[storage(read, write)]\n- fn swap(index_0: u64, index_1: u64) {\n- storage.my_vec.swap(index_0, index_1);\n- }\n-\n- #[storage(read)]\n- fn first() -> bool {\n- storage.my_vec.first().unwrap().read()\n- }\n-\n- #[storage(read)]\n- fn last() -> bool {\n- storage.my_vec.last().unwrap().read()\n- }\n-\n- #[storage(read, write)]\n- fn reverse() {\n- storage.my_vec.reverse();\n- }\n-\n- #[storage(read, write)]\n- fn fill(value: bool) {\n- storage.my_vec.fill(value);\n- }\n-\n- #[storage(read, write)]\n- fn resize(new_len: u64, value: bool) {\n- storage.my_vec.resize(new_len, value);\n- }\n-}\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_enum/Forc.lock b/test/src/sdk-harness/test_artifacts/storage_vec/svec_enum/Forc.lock\ndeleted file mode 100644\nindex 304cdb81210..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_enum/Forc.lock\n+++ /dev/null\n@@ -1,13 +0,0 @@\n-[[package]]\n-name = 'core'\n-source = 'path+from-root-BA7DA646BFFC59D3'\n-\n-[[package]]\n-name = 'std'\n-source = 'path+from-root-BA7DA646BFFC59D3'\n-dependencies = ['core']\n-\n-[[package]]\n-name = 'svec_enum'\n-source = 'member'\n-dependencies = ['std']\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_enum/Forc.toml b/test/src/sdk-harness/test_artifacts/storage_vec/svec_enum/Forc.toml\ndeleted file mode 100644\nindex 6714176a6a2..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_enum/Forc.toml\n+++ /dev/null\n@@ -1,8 +0,0 @@\n-[project]\n-authors = [\"Fuel Labs <contact@fuel.sh>\"]\n-entry = \"main.sw\"\n-license = \"Apache-2.0\"\n-name = \"svec_enum\"\n-\n-[dependencies]\n-std = { path = \"../../../../../../sway-lib-std\" }\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_enum/src/main.sw b/test/src/sdk-harness/test_artifacts/storage_vec/svec_enum/src/main.sw\ndeleted file mode 100644\nindex 6ef8b91991d..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_enum/src/main.sw\n+++ /dev/null\n@@ -1,144 +0,0 @@\n-contract;\n-\n-use std::storage::storage_vec::*;\n-\n-enum TestEnum {\n- A: bool,\n- B: u16,\n-}\n-\n-abi MyContract {\n- #[storage(read, write)]\n- fn push(value: TestEnum);\n-\n- #[storage(read, write)]\n- fn pop() -> TestEnum;\n-\n- #[storage(read)]\n- fn get(index: u64) -> TestEnum;\n-\n- #[storage(read, write)]\n- fn remove(index: u64) -> TestEnum;\n-\n- #[storage(read, write)]\n- fn swap_remove(index: u64) -> TestEnum;\n-\n- #[storage(read, write)]\n- fn set(index: u64, value: TestEnum);\n-\n- #[storage(read, write)]\n- fn insert(index: u64, value: TestEnum);\n-\n- #[storage(read)]\n- fn len() -> u64;\n-\n- #[storage(read)]\n- fn is_empty() -> bool;\n-\n- #[storage(write)]\n- fn clear();\n-\n- #[storage(read, write)]\n- fn swap(index_0: u64, index_1: u64);\n-\n- #[storage(read)]\n- fn first() -> TestEnum;\n-\n- #[storage(read)]\n- fn last() -> TestEnum;\n-\n- #[storage(read, write)]\n- fn reverse();\n-\n- #[storage(read, write)]\n- fn fill(value: TestEnum);\n-\n- #[storage(read, write)]\n- fn resize(new_len: u64, value: TestEnum);\n-}\n-\n-storage {\n- my_vec: StorageVec<TestEnum> = StorageVec {},\n-}\n-\n-impl MyContract for Contract {\n- #[storage(read, write)]\n- fn push(value: TestEnum) {\n- storage.my_vec.push(value);\n- }\n-\n- #[storage(read, write)]\n- fn pop() -> TestEnum {\n- storage.my_vec.pop().unwrap()\n- }\n-\n- #[storage(read)]\n- fn get(index: u64) -> TestEnum {\n- storage.my_vec.get(index).unwrap().read()\n- }\n-\n- #[storage(read, write)]\n- fn remove(index: u64) -> TestEnum {\n- storage.my_vec.remove(index)\n- }\n-\n- #[storage(read, write)]\n- fn swap_remove(index: u64) -> TestEnum {\n- storage.my_vec.swap_remove(index)\n- }\n-\n- #[storage(read, write)]\n- fn set(index: u64, value: TestEnum) {\n- storage.my_vec.set(index, value);\n- }\n-\n- #[storage(read, write)]\n- fn insert(index: u64, value: TestEnum) {\n- storage.my_vec.insert(index, value);\n- }\n-\n- #[storage(read)]\n- fn len() -> u64 {\n- storage.my_vec.len()\n- }\n-\n- #[storage(read)]\n- fn is_empty() -> bool {\n- storage.my_vec.is_empty()\n- }\n-\n- #[storage(write)]\n- fn clear() {\n- let _ = storage.my_vec.clear();\n- }\n-\n- #[storage(read, write)]\n- fn swap(index_0: u64, index_1: u64) {\n- storage.my_vec.swap(index_0, index_1);\n- }\n-\n- #[storage(read)]\n- fn first() -> TestEnum {\n- storage.my_vec.first().unwrap().read()\n- }\n-\n- #[storage(read)]\n- fn last() -> TestEnum {\n- storage.my_vec.last().unwrap().read()\n- }\n-\n- #[storage(read, write)]\n- fn reverse() {\n- storage.my_vec.reverse();\n- }\n-\n- #[storage(read, write)]\n- fn fill(value: TestEnum) {\n- storage.my_vec.fill(value);\n- }\n-\n- #[storage(read, write)]\n- fn resize(new_len: u64, value: TestEnum) {\n- storage.my_vec.resize(new_len, value);\n- }\n-}\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_str/Forc.lock b/test/src/sdk-harness/test_artifacts/storage_vec/svec_str/Forc.lock\ndeleted file mode 100644\nindex 6379ae2b967..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_str/Forc.lock\n+++ /dev/null\n@@ -1,13 +0,0 @@\n-[[package]]\n-name = 'core'\n-source = 'path+from-root-5A8E0F2C8C65E65F'\n-\n-[[package]]\n-name = 'std'\n-source = 'path+from-root-5A8E0F2C8C65E65F'\n-dependencies = ['core']\n-\n-[[package]]\n-name = 'svec_str'\n-source = 'member'\n-dependencies = ['std']\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_str/Forc.toml b/test/src/sdk-harness/test_artifacts/storage_vec/svec_str/Forc.toml\ndeleted file mode 100644\nindex d65b979ece3..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_str/Forc.toml\n+++ /dev/null\n@@ -1,8 +0,0 @@\n-[project]\n-authors = [\"Fuel Labs <contact@fuel.sh>\"]\n-entry = \"main.sw\"\n-license = \"Apache-2.0\"\n-name = \"svec_str\"\n-\n-[dependencies]\n-std = { path = \"../../../../../../sway-lib-std\" }\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_str/src/main.sw b/test/src/sdk-harness/test_artifacts/storage_vec/svec_str/src/main.sw\ndeleted file mode 100644\nindex 5639be0b784..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_str/src/main.sw\n+++ /dev/null\n@@ -1,139 +0,0 @@\n-contract;\n-\n-use std::storage::storage_vec::*;\n-\n-abi MyContract {\n- #[storage(read, write)]\n- fn push(value: str[4]);\n-\n- #[storage(read, write)]\n- fn pop() -> str[4];\n-\n- #[storage(read)]\n- fn get(index: u64) -> str[4];\n-\n- #[storage(read, write)]\n- fn remove(index: u64) -> str[4];\n-\n- #[storage(read, write)]\n- fn swap_remove(index: u64) -> str[4];\n-\n- #[storage(read, write)]\n- fn set(index: u64, value: str[4]);\n-\n- #[storage(read, write)]\n- fn insert(index: u64, value: str[4]);\n-\n- #[storage(read)]\n- fn len() -> u64;\n-\n- #[storage(read)]\n- fn is_empty() -> bool;\n-\n- #[storage(write)]\n- fn clear();\n-\n- #[storage(read, write)]\n- fn swap(index_0: u64, index_1: u64);\n-\n- #[storage(read)]\n- fn first() -> str[4];\n-\n- #[storage(read)]\n- fn last() -> str[4];\n-\n- #[storage(read, write)]\n- fn reverse();\n-\n- #[storage(read, write)]\n- fn fill(value: str[4]);\n-\n- #[storage(read, write)]\n- fn resize(new_len: u64, value: str[4]);\n-}\n-\n-storage {\n- my_vec: StorageVec<str[4]> = StorageVec {},\n-}\n-\n-impl MyContract for Contract {\n- #[storage(read, write)]\n- fn push(value: str[4]) {\n- storage.my_vec.push(value);\n- }\n-\n- #[storage(read, write)]\n- fn pop() -> str[4] {\n- storage.my_vec.pop().unwrap()\n- }\n-\n- #[storage(read)]\n- fn get(index: u64) -> str[4] {\n- storage.my_vec.get(index).unwrap().read()\n- }\n-\n- #[storage(read, write)]\n- fn remove(index: u64) -> str[4] {\n- storage.my_vec.remove(index)\n- }\n-\n- #[storage(read, write)]\n- fn swap_remove(index: u64) -> str[4] {\n- storage.my_vec.swap_remove(index)\n- }\n-\n- #[storage(read, write)]\n- fn set(index: u64, value: str[4]) {\n- storage.my_vec.set(index, value);\n- }\n-\n- #[storage(read, write)]\n- fn insert(index: u64, value: str[4]) {\n- storage.my_vec.insert(index, value);\n- }\n-\n- #[storage(read)]\n- fn len() -> u64 {\n- storage.my_vec.len()\n- }\n-\n- #[storage(read)]\n- fn is_empty() -> bool {\n- storage.my_vec.is_empty()\n- }\n-\n- #[storage(write)]\n- fn clear() {\n- let _ = storage.my_vec.clear();\n- }\n-\n- #[storage(read, write)]\n- fn swap(index_0: u64, index_1: u64) {\n- storage.my_vec.swap(index_0, index_1);\n- }\n-\n- #[storage(read)]\n- fn first() -> str[4] {\n- storage.my_vec.first().unwrap().read()\n- }\n-\n- #[storage(read)]\n- fn last() -> str[4] {\n- storage.my_vec.last().unwrap().read()\n- }\n-\n- #[storage(read, write)]\n- fn reverse() {\n- storage.my_vec.reverse();\n- }\n-\n- #[storage(read, write)]\n- fn fill(value: str[4]) {\n- storage.my_vec.fill(value);\n- }\n-\n- #[storage(read, write)]\n- fn resize(new_len: u64, value: str[4]) {\n- storage.my_vec.resize(new_len, value);\n- }\n-}\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_struct/Forc.lock b/test/src/sdk-harness/test_artifacts/storage_vec/svec_struct/Forc.lock\ndeleted file mode 100644\nindex 8a78e4c6546..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_struct/Forc.lock\n+++ /dev/null\n@@ -1,13 +0,0 @@\n-[[package]]\n-name = 'core'\n-source = 'path+from-root-5D548BD88B479EAC'\n-\n-[[package]]\n-name = 'std'\n-source = 'path+from-root-5D548BD88B479EAC'\n-dependencies = ['core']\n-\n-[[package]]\n-name = 'svec_struct'\n-source = 'member'\n-dependencies = ['std']\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_struct/Forc.toml b/test/src/sdk-harness/test_artifacts/storage_vec/svec_struct/Forc.toml\ndeleted file mode 100644\nindex 8ad370c395f..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_struct/Forc.toml\n+++ /dev/null\n@@ -1,8 +0,0 @@\n-[project]\n-authors = [\"Fuel Labs <contact@fuel.sh>\"]\n-entry = \"main.sw\"\n-license = \"Apache-2.0\"\n-name = \"svec_struct\"\n-\n-[dependencies]\n-std = { path = \"../../../../../../sway-lib-std\" }\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_struct/src/main.sw b/test/src/sdk-harness/test_artifacts/storage_vec/svec_struct/src/main.sw\ndeleted file mode 100644\nindex 0ef1b70ed3c..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_struct/src/main.sw\n+++ /dev/null\n@@ -1,144 +0,0 @@\n-contract;\n-\n-use std::storage::storage_vec::*;\n-\n-struct TestStruct {\n- a: bool,\n- b: u16,\n-}\n-\n-abi MyContract {\n- #[storage(read, write)]\n- fn push(value: TestStruct);\n-\n- #[storage(read, write)]\n- fn pop() -> TestStruct;\n-\n- #[storage(read)]\n- fn get(index: u64) -> TestStruct;\n-\n- #[storage(read, write)]\n- fn remove(index: u64) -> TestStruct;\n-\n- #[storage(read, write)]\n- fn swap_remove(index: u64) -> TestStruct;\n-\n- #[storage(read, write)]\n- fn set(index: u64, value: TestStruct);\n-\n- #[storage(read, write)]\n- fn insert(index: u64, value: TestStruct);\n-\n- #[storage(read)]\n- fn len() -> u64;\n-\n- #[storage(read)]\n- fn is_empty() -> bool;\n-\n- #[storage(write)]\n- fn clear();\n-\n- #[storage(read, write)]\n- fn swap(index_0: u64, index_1: u64);\n-\n- #[storage(read)]\n- fn first() -> TestStruct;\n-\n- #[storage(read)]\n- fn last() -> TestStruct;\n-\n- #[storage(read, write)]\n- fn reverse();\n-\n- #[storage(read, write)]\n- fn fill(value: TestStruct);\n-\n- #[storage(read, write)]\n- fn resize(new_len: u64, value: TestStruct);\n-}\n-\n-storage {\n- my_vec: StorageVec<TestStruct> = StorageVec {},\n-}\n-\n-impl MyContract for Contract {\n- #[storage(read, write)]\n- fn push(value: TestStruct) {\n- storage.my_vec.push(value);\n- }\n-\n- #[storage(read, write)]\n- fn pop() -> TestStruct {\n- storage.my_vec.pop().unwrap()\n- }\n-\n- #[storage(read)]\n- fn get(index: u64) -> TestStruct {\n- storage.my_vec.get(index).unwrap().read()\n- }\n-\n- #[storage(read, write)]\n- fn remove(index: u64) -> TestStruct {\n- storage.my_vec.remove(index)\n- }\n-\n- #[storage(read, write)]\n- fn swap_remove(index: u64) -> TestStruct {\n- storage.my_vec.swap_remove(index)\n- }\n-\n- #[storage(read, write)]\n- fn set(index: u64, value: TestStruct) {\n- storage.my_vec.set(index, value);\n- }\n-\n- #[storage(read, write)]\n- fn insert(index: u64, value: TestStruct) {\n- storage.my_vec.insert(index, value);\n- }\n-\n- #[storage(read)]\n- fn len() -> u64 {\n- storage.my_vec.len()\n- }\n-\n- #[storage(read)]\n- fn is_empty() -> bool {\n- storage.my_vec.is_empty()\n- }\n-\n- #[storage(write)]\n- fn clear() {\n- let _ = storage.my_vec.clear();\n- }\n-\n- #[storage(read, write)]\n- fn swap(index_0: u64, index_1: u64) {\n- storage.my_vec.swap(index_0, index_1);\n- }\n-\n- #[storage(read)]\n- fn first() -> TestStruct {\n- storage.my_vec.first().unwrap().read()\n- }\n-\n- #[storage(read)]\n- fn last() -> TestStruct {\n- storage.my_vec.last().unwrap().read()\n- }\n-\n- #[storage(read, write)]\n- fn reverse() {\n- storage.my_vec.reverse();\n- }\n-\n- #[storage(read, write)]\n- fn fill(value: TestStruct) {\n- storage.my_vec.fill(value);\n- }\n-\n- #[storage(read, write)]\n- fn resize(new_len: u64, value: TestStruct) {\n- storage.my_vec.resize(new_len, value);\n- }\n-}\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_tuple/Forc.lock b/test/src/sdk-harness/test_artifacts/storage_vec/svec_tuple/Forc.lock\ndeleted file mode 100644\nindex 10605f68ece..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_tuple/Forc.lock\n+++ /dev/null\n@@ -1,13 +0,0 @@\n-[[package]]\n-name = 'core'\n-source = 'path+from-root-ADD23FE8604712AD'\n-\n-[[package]]\n-name = 'std'\n-source = 'path+from-root-ADD23FE8604712AD'\n-dependencies = ['core']\n-\n-[[package]]\n-name = 'svec_tuple'\n-source = 'member'\n-dependencies = ['std']\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_tuple/Forc.toml b/test/src/sdk-harness/test_artifacts/storage_vec/svec_tuple/Forc.toml\ndeleted file mode 100644\nindex 1f758d6e607..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_tuple/Forc.toml\n+++ /dev/null\n@@ -1,8 +0,0 @@\n-[project]\n-authors = [\"Fuel Labs <contact@fuel.sh>\"]\n-entry = \"main.sw\"\n-license = \"Apache-2.0\"\n-name = \"svec_tuple\"\n-\n-[dependencies]\n-std = { path = \"../../../../../../sway-lib-std\" }\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_tuple/src/main.sw b/test/src/sdk-harness/test_artifacts/storage_vec/svec_tuple/src/main.sw\ndeleted file mode 100644\nindex 2fed33be932..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_tuple/src/main.sw\n+++ /dev/null\n@@ -1,139 +0,0 @@\n-contract;\n-\n-use std::storage::storage_vec::*;\n-\n-abi MyContract {\n- #[storage(read, write)]\n- fn push(value: (u8, u8, u8));\n-\n- #[storage(read, write)]\n- fn pop() -> (u8, u8, u8);\n-\n- #[storage(read)]\n- fn get(index: u64) -> (u8, u8, u8);\n-\n- #[storage(read, write)]\n- fn remove(index: u64) -> (u8, u8, u8);\n-\n- #[storage(read, write)]\n- fn swap_remove(index: u64) -> (u8, u8, u8);\n-\n- #[storage(read, write)]\n- fn set(index: u64, value: (u8, u8, u8));\n-\n- #[storage(read, write)]\n- fn insert(index: u64, value: (u8, u8, u8));\n-\n- #[storage(read)]\n- fn len() -> u64;\n-\n- #[storage(read)]\n- fn is_empty() -> bool;\n-\n- #[storage(write)]\n- fn clear();\n-\n- #[storage(read, write)]\n- fn swap(index_0: u64, index_1: u64);\n-\n- #[storage(read)]\n- fn first() -> (u8, u8, u8);\n-\n- #[storage(read)]\n- fn last() -> (u8, u8, u8);\n-\n- #[storage(read, write)]\n- fn reverse();\n-\n- #[storage(read, write)]\n- fn fill(value: (u8, u8, u8));\n-\n- #[storage(read, write)]\n- fn resize(new_len: u64, value: (u8, u8, u8));\n-}\n-\n-storage {\n- my_vec: StorageVec<(u8, u8, u8)> = StorageVec {},\n-}\n-\n-impl MyContract for Contract {\n- #[storage(read, write)]\n- fn push(value: (u8, u8, u8)) {\n- storage.my_vec.push(value);\n- }\n-\n- #[storage(read, write)]\n- fn pop() -> (u8, u8, u8) {\n- storage.my_vec.pop().unwrap()\n- }\n-\n- #[storage(read)]\n- fn get(index: u64) -> (u8, u8, u8) {\n- storage.my_vec.get(index).unwrap().read()\n- }\n-\n- #[storage(read, write)]\n- fn remove(index: u64) -> (u8, u8, u8) {\n- storage.my_vec.remove(index)\n- }\n-\n- #[storage(read, write)]\n- fn swap_remove(index: u64) -> (u8, u8, u8) {\n- storage.my_vec.swap_remove(index)\n- }\n-\n- #[storage(read, write)]\n- fn set(index: u64, value: (u8, u8, u8)) {\n- storage.my_vec.set(index, value);\n- }\n-\n- #[storage(read, write)]\n- fn insert(index: u64, value: (u8, u8, u8)) {\n- storage.my_vec.insert(index, value);\n- }\n-\n- #[storage(read)]\n- fn len() -> u64 {\n- storage.my_vec.len()\n- }\n-\n- #[storage(read)]\n- fn is_empty() -> bool {\n- storage.my_vec.is_empty()\n- }\n-\n- #[storage(write)]\n- fn clear() {\n- let _ = storage.my_vec.clear();\n- }\n-\n- #[storage(read, write)]\n- fn swap(index_0: u64, index_1: u64) {\n- storage.my_vec.swap(index_0, index_1);\n- }\n-\n- #[storage(read)]\n- fn first() -> (u8, u8, u8) {\n- storage.my_vec.first().unwrap().read()\n- }\n-\n- #[storage(read)]\n- fn last() -> (u8, u8, u8) {\n- storage.my_vec.last().unwrap().read()\n- }\n-\n- #[storage(read, write)]\n- fn reverse() {\n- storage.my_vec.reverse();\n- }\n-\n- #[storage(read, write)]\n- fn fill(value: (u8, u8, u8)) {\n- storage.my_vec.fill(value);\n- }\n-\n- #[storage(read, write)]\n- fn resize(new_len: u64, value: (u8, u8, u8)) {\n- storage.my_vec.resize(new_len, value);\n- }\n-}\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_u16/Forc.lock b/test/src/sdk-harness/test_artifacts/storage_vec/svec_u16/Forc.lock\ndeleted file mode 100644\nindex fd0ea83faae..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_u16/Forc.lock\n+++ /dev/null\n@@ -1,13 +0,0 @@\n-[[package]]\n-name = 'core'\n-source = 'path+from-root-D2C27CF3A144E426'\n-\n-[[package]]\n-name = 'std'\n-source = 'path+from-root-D2C27CF3A144E426'\n-dependencies = ['core']\n-\n-[[package]]\n-name = 'svec_u16'\n-source = 'member'\n-dependencies = ['std']\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_u16/Forc.toml b/test/src/sdk-harness/test_artifacts/storage_vec/svec_u16/Forc.toml\ndeleted file mode 100644\nindex a2f5b819f5b..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_u16/Forc.toml\n+++ /dev/null\n@@ -1,8 +0,0 @@\n-[project]\n-authors = [\"Fuel Labs <contact@fuel.sh>\"]\n-entry = \"main.sw\"\n-license = \"Apache-2.0\"\n-name = \"svec_u16\"\n-\n-[dependencies]\n-std = { path = \"../../../../../../sway-lib-std\" }\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_u16/src/main.sw b/test/src/sdk-harness/test_artifacts/storage_vec/svec_u16/src/main.sw\ndeleted file mode 100644\nindex 476d9552991..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_u16/src/main.sw\n+++ /dev/null\n@@ -1,139 +0,0 @@\n-contract;\n-\n-use std::storage::storage_vec::*;\n-\n-abi MyContract {\n- #[storage(read, write)]\n- fn push(value: u16);\n-\n- #[storage(read, write)]\n- fn pop() -> u16;\n-\n- #[storage(read)]\n- fn get(index: u64) -> u16;\n-\n- #[storage(read, write)]\n- fn remove(index: u64) -> u16;\n-\n- #[storage(read, write)]\n- fn swap_remove(index: u64) -> u16;\n-\n- #[storage(read, write)]\n- fn set(index: u64, value: u16);\n-\n- #[storage(read, write)]\n- fn insert(index: u64, value: u16);\n-\n- #[storage(read)]\n- fn len() -> u64;\n-\n- #[storage(read)]\n- fn is_empty() -> bool;\n-\n- #[storage(write)]\n- fn clear();\n-\n- #[storage(read, write)]\n- fn swap(index_0: u64, index_1: u64);\n-\n- #[storage(read)]\n- fn first() -> u16;\n-\n- #[storage(read)]\n- fn last() -> u16;\n-\n- #[storage(read, write)]\n- fn reverse();\n-\n- #[storage(read, write)]\n- fn fill(value: u16);\n-\n- #[storage(read, write)]\n- fn resize(new_len: u64, value: u16);\n-}\n-\n-storage {\n- my_vec: StorageVec<u16> = StorageVec {},\n-}\n-\n-impl MyContract for Contract {\n- #[storage(read, write)]\n- fn push(value: u16) {\n- storage.my_vec.push(value);\n- }\n-\n- #[storage(read, write)]\n- fn pop() -> u16 {\n- storage.my_vec.pop().unwrap()\n- }\n-\n- #[storage(read)]\n- fn get(index: u64) -> u16 {\n- storage.my_vec.get(index).unwrap().read()\n- }\n-\n- #[storage(read, write)]\n- fn remove(index: u64) -> u16 {\n- storage.my_vec.remove(index)\n- }\n-\n- #[storage(read, write)]\n- fn swap_remove(index: u64) -> u16 {\n- storage.my_vec.swap_remove(index)\n- }\n-\n- #[storage(read, write)]\n- fn set(index: u64, value: u16) {\n- storage.my_vec.set(index, value);\n- }\n-\n- #[storage(read, write)]\n- fn insert(index: u64, value: u16) {\n- storage.my_vec.insert(index, value);\n- }\n-\n- #[storage(read)]\n- fn len() -> u64 {\n- storage.my_vec.len()\n- }\n-\n- #[storage(read)]\n- fn is_empty() -> bool {\n- storage.my_vec.is_empty()\n- }\n-\n- #[storage(write)]\n- fn clear() {\n- let _ = storage.my_vec.clear();\n- }\n-\n- #[storage(read, write)]\n- fn swap(index_0: u64, index_1: u64) {\n- storage.my_vec.swap(index_0, index_1);\n- }\n-\n- #[storage(read)]\n- fn first() -> u16 {\n- storage.my_vec.first().unwrap().read()\n- }\n-\n- #[storage(read)]\n- fn last() -> u16 {\n- storage.my_vec.last().unwrap().read()\n- }\n-\n- #[storage(read, write)]\n- fn reverse() {\n- storage.my_vec.reverse();\n- }\n-\n- #[storage(read, write)]\n- fn fill(value: u16) {\n- storage.my_vec.fill(value);\n- }\n-\n- #[storage(read, write)]\n- fn resize(new_len: u64, value: u16) {\n- storage.my_vec.resize(new_len, value);\n- }\n-}\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_u32/Forc.lock b/test/src/sdk-harness/test_artifacts/storage_vec/svec_u32/Forc.lock\ndeleted file mode 100644\nindex 1f7e33e0bc3..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_u32/Forc.lock\n+++ /dev/null\n@@ -1,13 +0,0 @@\n-[[package]]\n-name = 'core'\n-source = 'path+from-root-273E1774DB1237EA'\n-\n-[[package]]\n-name = 'std'\n-source = 'path+from-root-273E1774DB1237EA'\n-dependencies = ['core']\n-\n-[[package]]\n-name = 'svec_u32'\n-source = 'member'\n-dependencies = ['std']\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_u32/Forc.toml b/test/src/sdk-harness/test_artifacts/storage_vec/svec_u32/Forc.toml\ndeleted file mode 100644\nindex 8356145b78d..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_u32/Forc.toml\n+++ /dev/null\n@@ -1,8 +0,0 @@\n-[project]\n-authors = [\"Fuel Labs <contact@fuel.sh>\"]\n-entry = \"main.sw\"\n-license = \"Apache-2.0\"\n-name = \"svec_u32\"\n-\n-[dependencies]\n-std = { path = \"../../../../../../sway-lib-std\" }\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_u32/src/main.sw b/test/src/sdk-harness/test_artifacts/storage_vec/svec_u32/src/main.sw\ndeleted file mode 100644\nindex 7a240bcc41e..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_u32/src/main.sw\n+++ /dev/null\n@@ -1,139 +0,0 @@\n-contract;\n-\n-use std::storage::storage_vec::*;\n-\n-abi MyContract {\n- #[storage(read, write)]\n- fn push(value: u32);\n-\n- #[storage(read, write)]\n- fn pop() -> u32;\n-\n- #[storage(read)]\n- fn get(index: u64) -> u32;\n-\n- #[storage(read, write)]\n- fn remove(index: u64) -> u32;\n-\n- #[storage(read, write)]\n- fn swap_remove(index: u64) -> u32;\n-\n- #[storage(read, write)]\n- fn set(index: u64, value: u32);\n-\n- #[storage(read, write)]\n- fn insert(index: u64, value: u32);\n-\n- #[storage(read)]\n- fn len() -> u64;\n-\n- #[storage(read)]\n- fn is_empty() -> bool;\n-\n- #[storage(write)]\n- fn clear();\n-\n- #[storage(read, write)]\n- fn swap(index_0: u64, index_1: u64);\n-\n- #[storage(read)]\n- fn first() -> u32;\n-\n- #[storage(read)]\n- fn last() -> u32;\n-\n- #[storage(read, write)]\n- fn reverse();\n-\n- #[storage(read, write)]\n- fn fill(value: u32);\n-\n- #[storage(read, write)]\n- fn resize(new_len: u64, value: u32);\n-}\n-\n-storage {\n- my_vec: StorageVec<u32> = StorageVec {},\n-}\n-\n-impl MyContract for Contract {\n- #[storage(read, write)]\n- fn push(value: u32) {\n- storage.my_vec.push(value);\n- }\n-\n- #[storage(read, write)]\n- fn pop() -> u32 {\n- storage.my_vec.pop().unwrap()\n- }\n-\n- #[storage(read)]\n- fn get(index: u64) -> u32 {\n- storage.my_vec.get(index).unwrap().read()\n- }\n-\n- #[storage(read, write)]\n- fn remove(index: u64) -> u32 {\n- storage.my_vec.remove(index)\n- }\n-\n- #[storage(read, write)]\n- fn swap_remove(index: u64) -> u32 {\n- storage.my_vec.swap_remove(index)\n- }\n-\n- #[storage(read, write)]\n- fn set(index: u64, value: u32) {\n- storage.my_vec.set(index, value);\n- }\n-\n- #[storage(read, write)]\n- fn insert(index: u64, value: u32) {\n- storage.my_vec.insert(index, value);\n- }\n-\n- #[storage(read)]\n- fn len() -> u64 {\n- storage.my_vec.len()\n- }\n-\n- #[storage(read)]\n- fn is_empty() -> bool {\n- storage.my_vec.is_empty()\n- }\n-\n- #[storage(write)]\n- fn clear() {\n- let _ = storage.my_vec.clear();\n- }\n-\n- #[storage(read, write)]\n- fn swap(index_0: u64, index_1: u64) {\n- storage.my_vec.swap(index_0, index_1);\n- }\n-\n- #[storage(read)]\n- fn first() -> u32 {\n- storage.my_vec.first().unwrap().read()\n- }\n-\n- #[storage(read)]\n- fn last() -> u32 {\n- storage.my_vec.last().unwrap().read()\n- }\n-\n- #[storage(read, write)]\n- fn reverse() {\n- storage.my_vec.reverse();\n- }\n-\n- #[storage(read, write)]\n- fn fill(value: u32) {\n- storage.my_vec.fill(value);\n- }\n-\n- #[storage(read, write)]\n- fn resize(new_len: u64, value: u32) {\n- storage.my_vec.resize(new_len, value);\n- }\n-}\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_u64/Forc.lock b/test/src/sdk-harness/test_artifacts/storage_vec/svec_u64/Forc.lock\ndeleted file mode 100644\nindex 2ebf40199c7..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_u64/Forc.lock\n+++ /dev/null\n@@ -1,13 +0,0 @@\n-[[package]]\n-name = 'core'\n-source = 'path+from-root-1BF264D58B073501'\n-\n-[[package]]\n-name = 'std'\n-source = 'path+from-root-1BF264D58B073501'\n-dependencies = ['core']\n-\n-[[package]]\n-name = 'svec_u64'\n-source = 'member'\n-dependencies = ['std']\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_u64/Forc.toml b/test/src/sdk-harness/test_artifacts/storage_vec/svec_u64/Forc.toml\ndeleted file mode 100644\nindex beb8efb4f34..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_u64/Forc.toml\n+++ /dev/null\n@@ -1,8 +0,0 @@\n-[project]\n-authors = [\"Fuel Labs <contact@fuel.sh>\"]\n-entry = \"main.sw\"\n-license = \"Apache-2.0\"\n-name = \"svec_u64\"\n-\n-[dependencies]\n-std = { path = \"../../../../../../sway-lib-std\" }\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_u64/src/main.sw b/test/src/sdk-harness/test_artifacts/storage_vec/svec_u64/src/main.sw\ndeleted file mode 100644\nindex 154f80a89b0..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_u64/src/main.sw\n+++ /dev/null\n@@ -1,139 +0,0 @@\n-contract;\n-\n-use std::storage::storage_vec::*;\n-\n-abi MyContract {\n- #[storage(read, write)]\n- fn push(value: u64);\n-\n- #[storage(read, write)]\n- fn pop() -> u64;\n-\n- #[storage(read)]\n- fn get(index: u64) -> u64;\n-\n- #[storage(read, write)]\n- fn remove(index: u64) -> u64;\n-\n- #[storage(read, write)]\n- fn swap_remove(index: u64) -> u64;\n-\n- #[storage(read, write)]\n- fn set(index: u64, value: u64);\n-\n- #[storage(read, write)]\n- fn insert(index: u64, value: u64);\n-\n- #[storage(read)]\n- fn len() -> u64;\n-\n- #[storage(read)]\n- fn is_empty() -> bool;\n-\n- #[storage(write)]\n- fn clear();\n-\n- #[storage(read, write)]\n- fn swap(index_0: u64, index_1: u64);\n-\n- #[storage(read)]\n- fn first() -> u64;\n-\n- #[storage(read)]\n- fn last() -> u64;\n-\n- #[storage(read, write)]\n- fn reverse();\n-\n- #[storage(read, write)]\n- fn fill(value: u64);\n-\n- #[storage(read, write)]\n- fn resize(new_len: u64, value: u64);\n-}\n-\n-storage {\n- my_vec: StorageVec<u64> = StorageVec {},\n-}\n-\n-impl MyContract for Contract {\n- #[storage(read, write)]\n- fn push(value: u64) {\n- storage.my_vec.push(value);\n- }\n-\n- #[storage(read, write)]\n- fn pop() -> u64 {\n- storage.my_vec.pop().unwrap()\n- }\n-\n- #[storage(read)]\n- fn get(index: u64) -> u64 {\n- storage.my_vec.get(index).unwrap().read()\n- }\n-\n- #[storage(read, write)]\n- fn remove(index: u64) -> u64 {\n- storage.my_vec.remove(index)\n- }\n-\n- #[storage(read, write)]\n- fn swap_remove(index: u64) -> u64 {\n- storage.my_vec.swap_remove(index)\n- }\n-\n- #[storage(read, write)]\n- fn set(index: u64, value: u64) {\n- storage.my_vec.set(index, value);\n- }\n-\n- #[storage(read, write)]\n- fn insert(index: u64, value: u64) {\n- storage.my_vec.insert(index, value);\n- }\n-\n- #[storage(read)]\n- fn len() -> u64 {\n- storage.my_vec.len()\n- }\n-\n- #[storage(read)]\n- fn is_empty() -> bool {\n- storage.my_vec.is_empty()\n- }\n-\n- #[storage(write)]\n- fn clear() {\n- let _ = storage.my_vec.clear();\n- }\n-\n- #[storage(read, write)]\n- fn swap(index_0: u64, index_1: u64) {\n- storage.my_vec.swap(index_0, index_1);\n- }\n-\n- #[storage(read)]\n- fn first() -> u64 {\n- storage.my_vec.first().unwrap().read()\n- }\n-\n- #[storage(read)]\n- fn last() -> u64 {\n- storage.my_vec.last().unwrap().read()\n- }\n-\n- #[storage(read, write)]\n- fn reverse() {\n- storage.my_vec.reverse();\n- }\n-\n- #[storage(read, write)]\n- fn fill(value: u64) {\n- storage.my_vec.fill(value);\n- }\n-\n- #[storage(read, write)]\n- fn resize(new_len: u64, value: u64) {\n- storage.my_vec.resize(new_len, value);\n- }\n-}\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_u8/Forc.lock b/test/src/sdk-harness/test_artifacts/storage_vec/svec_u8/Forc.lock\ndeleted file mode 100644\nindex ef7a4866fed..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_u8/Forc.lock\n+++ /dev/null\n@@ -1,13 +0,0 @@\n-[[package]]\n-name = 'core'\n-source = 'path+from-root-0A9A4F1E1D370290'\n-\n-[[package]]\n-name = 'std'\n-source = 'path+from-root-0A9A4F1E1D370290'\n-dependencies = ['core']\n-\n-[[package]]\n-name = 'svec_u8'\n-source = 'member'\n-dependencies = ['std']\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_u8/Forc.toml b/test/src/sdk-harness/test_artifacts/storage_vec/svec_u8/Forc.toml\ndeleted file mode 100644\nindex 66a399e3211..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_u8/Forc.toml\n+++ /dev/null\n@@ -1,8 +0,0 @@\n-[project]\n-authors = [\"Fuel Labs <contact@fuel.sh>\"]\n-entry = \"main.sw\"\n-license = \"Apache-2.0\"\n-name = \"svec_u8\"\n-\n-[dependencies]\n-std = { path = \"../../../../../../sway-lib-std\" }\ndiff --git a/test/src/sdk-harness/test_artifacts/storage_vec/svec_u8/src/main.sw b/test/src/sdk-harness/test_artifacts/storage_vec/svec_u8/src/main.sw\ndeleted file mode 100644\nindex a16b29581be..00000000000\n--- a/test/src/sdk-harness/test_artifacts/storage_vec/svec_u8/src/main.sw\n+++ /dev/null\n@@ -1,139 +0,0 @@\n-contract;\n-\n-use std::storage::storage_vec::*;\n-\n-abi MyContract {\n- #[storage(read, write)]\n- fn push(value: u8);\n-\n- #[storage(read, write)]\n- fn pop() -> u8;\n-\n- #[storage(read)]\n- fn get(index: u64) -> u8;\n-\n- #[storage(read, write)]\n- fn remove(index: u64) -> u8;\n-\n- #[storage(read, write)]\n- fn swap_remove(index: u64) -> u8;\n-\n- #[storage(read, write)]\n- fn set(index: u64, value: u8);\n-\n- #[storage(read, write)]\n- fn insert(index: u64, value: u8);\n-\n- #[storage(read)]\n- fn len() -> u64;\n-\n- #[storage(read)]\n- fn is_empty() -> bool;\n-\n- #[storage(write)]\n- fn clear();\n-\n- #[storage(read, write)]\n- fn swap(index_0: u64, index_1: u64);\n-\n- #[storage(read)]\n- fn first() -> u8;\n-\n- #[storage(read)]\n- fn last() -> u8;\n-\n- #[storage(read, write)]\n- fn reverse();\n-\n- #[storage(read, write)]\n- fn fill(value: u8);\n-\n- #[storage(read, write)]\n- fn resize(new_len: u64, value: u8);\n-}\n-\n-storage {\n- my_vec: StorageVec<u8> = StorageVec {},\n-}\n-\n-impl MyContract for Contract {\n- #[storage(read, write)]\n- fn push(value: u8) {\n- storage.my_vec.push(value);\n- }\n-\n- #[storage(read, write)]\n- fn pop() -> u8 {\n- storage.my_vec.pop().unwrap()\n- }\n-\n- #[storage(read)]\n- fn get(index: u64) -> u8 {\n- storage.my_vec.get(index).unwrap().read()\n- }\n-\n- #[storage(read, write)]\n- fn remove(index: u64) -> u8 {\n- storage.my_vec.remove(index)\n- }\n-\n- #[storage(read, write)]\n- fn swap_remove(index: u64) -> u8 {\n- storage.my_vec.swap_remove(index)\n- }\n-\n- #[storage(read, write)]\n- fn set(index: u64, value: u8) {\n- storage.my_vec.set(index, value);\n- }\n-\n- #[storage(read, write)]\n- fn insert(index: u64, value: u8) {\n- storage.my_vec.insert(index, value);\n- }\n-\n- #[storage(read)]\n- fn len() -> u64 {\n- storage.my_vec.len()\n- }\n-\n- #[storage(read)]\n- fn is_empty() -> bool {\n- storage.my_vec.is_empty()\n- }\n-\n- #[storage(write)]\n- fn clear() {\n- let _ = storage.my_vec.clear();\n- }\n-\n- #[storage(read, write)]\n- fn swap(index_0: u64, index_1: u64) {\n- storage.my_vec.swap(index_0, index_1);\n- }\n-\n- #[storage(read)]\n- fn first() -> u8 {\n- storage.my_vec.first().unwrap().read()\n- }\n-\n- #[storage(read)]\n- fn last() -> u8 {\n- storage.my_vec.last().unwrap().read()\n- }\n-\n- #[storage(read, write)]\n- fn reverse() {\n- storage.my_vec.reverse();\n- }\n-\n- #[storage(read, write)]\n- fn fill(value: u8) {\n- storage.my_vec.fill(value);\n- }\n-\n- #[storage(read, write)]\n- fn resize(new_len: u64, value: u8) {\n- storage.my_vec.resize(new_len, value);\n- }\n-}\ndiff --git a/test/src/sdk-harness/test_projects/harness.rs b/test/src/sdk-harness/test_projects/harness.rs\nindex 97ed1aa7a5f..86fcfba6914 100644\n--- a/test/src/sdk-harness/test_projects/harness.rs\n+++ b/test/src/sdk-harness/test_projects/harness.rs\n@@ -41,11 +41,7 @@ mod storage_init;\n mod storage_map;\n mod storage_map_nested;\n mod storage_string;\n-// TODO: (STORAGE-VEC) Uncomment once `StorageVec` is implemented for dynamic storage.\n-// mod storage_vec;\n-// mod storage_vec_nested;\n-// mod storage_vec_of_storage_string;\n-// mod storage_vec_to_vec;\n+mod storage_vec_of_storage_string;\n mod string_slice;\n mod superabi;\n mod superabi_supertrait;\ndiff --git a/test/src/sdk-harness/test_projects/storage_vec/mod.rs b/test/src/sdk-harness/test_projects/storage_vec/mod.rs\ndeleted file mode 100644\nindex 5f2bc30396f..00000000000\n--- a/test/src/sdk-harness/test_projects/storage_vec/mod.rs\n+++ /dev/null\n@@ -1,14 +0,0 @@\n-#[macro_use]\n-mod testgen;\n-\n-mod svec_array;\n-mod svec_b256;\n-mod svec_bool;\n-mod svec_enum;\n-mod svec_str;\n-mod svec_struct;\n-mod svec_tuple;\n-mod svec_u16;\n-mod svec_u32;\n-mod svec_u64;\n-mod svec_u8;\ndiff --git a/test/src/sdk-harness/test_projects/storage_vec/svec_array.rs b/test/src/sdk-harness/test_projects/storage_vec/svec_array.rs\ndeleted file mode 100644\nindex f817b83cf49..00000000000\n--- a/test/src/sdk-harness/test_projects/storage_vec/svec_array.rs\n+++ /dev/null\n@@ -1,11 +0,0 @@\n-testgen!(\n- test_array_vec,\n- \"out/svec_array-abi.json\",\n- \"array\",\n- [u8; 3],\n- [1; 3],\n- [2; 3],\n- [3; 3],\n- [4; 3],\n- [5; 3]\n-);\ndiff --git a/test/src/sdk-harness/test_projects/storage_vec/svec_b256.rs b/test/src/sdk-harness/test_projects/storage_vec/svec_b256.rs\ndeleted file mode 100644\nindex 070ecd72f86..00000000000\n--- a/test/src/sdk-harness/test_projects/storage_vec/svec_b256.rs\n+++ /dev/null\n@@ -1,11 +0,0 @@\n-testgen!(\n- test_b256_vec,\n- \"out/svec_b256-abi.json\",\n- \"b256\",\n- ::fuels::types::Bits256,\n- ::fuels::types::Bits256([1; 32]),\n- ::fuels::types::Bits256([2; 32]),\n- ::fuels::types::Bits256([3; 32]),\n- ::fuels::types::Bits256([4; 32]),\n- ::fuels::types::Bits256([5; 32])\n-);\ndiff --git a/test/src/sdk-harness/test_projects/storage_vec/svec_bool.rs b/test/src/sdk-harness/test_projects/storage_vec/svec_bool.rs\ndeleted file mode 100644\nindex ce908407cdc..00000000000\n--- a/test/src/sdk-harness/test_projects/storage_vec/svec_bool.rs\n+++ /dev/null\n@@ -1,11 +0,0 @@\n-testgen!(\n- test_bool_vec,\n- \"out/svec_bool-abi.json\",\n- \"bool\",\n- bool,\n- true,\n- true,\n- false,\n- true,\n- false\n-);\ndiff --git a/test/src/sdk-harness/test_projects/storage_vec/svec_enum.rs b/test/src/sdk-harness/test_projects/storage_vec/svec_enum.rs\ndeleted file mode 100644\nindex 021c79ba088..00000000000\n--- a/test/src/sdk-harness/test_projects/storage_vec/svec_enum.rs\n+++ /dev/null\n@@ -1,11 +0,0 @@\n-testgen!(\n- test_enum_vec,\n- \"out/svec_enum-abi.json\",\n- \"enum\",\n- TestEnum,\n- TestEnum::A(true),\n- TestEnum::A(false),\n- TestEnum::B(1),\n- TestEnum::B(3),\n- TestEnum::B(2)\n-);\ndiff --git a/test/src/sdk-harness/test_projects/storage_vec/svec_str.rs b/test/src/sdk-harness/test_projects/storage_vec/svec_str.rs\ndeleted file mode 100644\nindex 31f154998a6..00000000000\n--- a/test/src/sdk-harness/test_projects/storage_vec/svec_str.rs\n+++ /dev/null\n@@ -1,11 +0,0 @@\n-testgen!(\n- test_str_vec,\n- \"out/svec_str-abi.json\",\n- \"str\",\n- ::fuels::types::SizedAsciiString::<4>,\n- ::fuels::types::SizedAsciiString::<4>::new(\"yeet\".to_string()).unwrap(),\n- ::fuels::types::SizedAsciiString::<4>::new(\"meow\".to_string()).unwrap(),\n- ::fuels::types::SizedAsciiString::<4>::new(\"kekw\".to_string()).unwrap(),\n- ::fuels::types::SizedAsciiString::<4>::new(\"gmgn\".to_string()).unwrap(),\n- ::fuels::types::SizedAsciiString::<4>::new(\"sway\".to_string()).unwrap()\n-);\ndiff --git a/test/src/sdk-harness/test_projects/storage_vec/svec_struct.rs b/test/src/sdk-harness/test_projects/storage_vec/svec_struct.rs\ndeleted file mode 100644\nindex 796dddc5c48..00000000000\n--- a/test/src/sdk-harness/test_projects/storage_vec/svec_struct.rs\n+++ /dev/null\n@@ -1,11 +0,0 @@\n-testgen!(\n- test_struct_vec,\n- \"out/svec_struct-abi.json\",\n- \"struct\",\n- TestStruct,\n- TestStruct { a: true, b: 1 },\n- TestStruct { a: false, b: 2 },\n- TestStruct { a: true, b: 3 },\n- TestStruct { a: false, b: 4 },\n- TestStruct { a: true, b: 5 }\n-);\ndiff --git a/test/src/sdk-harness/test_projects/storage_vec/svec_tuple.rs b/test/src/sdk-harness/test_projects/storage_vec/svec_tuple.rs\ndeleted file mode 100644\nindex 0210c580af2..00000000000\n--- a/test/src/sdk-harness/test_projects/storage_vec/svec_tuple.rs\n+++ /dev/null\n@@ -1,11 +0,0 @@\n-testgen!(\n- test_tuple_vec,\n- \"out/svec_tuple-abi.json\",\n- \"tuple\",\n- (u8, u8, u8),\n- (1, 1, 1),\n- (2, 2, 2),\n- (4, 4, 4),\n- (5, 5, 5),\n- (6, 6, 6)\n-);\ndiff --git a/test/src/sdk-harness/test_projects/storage_vec/svec_u16.rs b/test/src/sdk-harness/test_projects/storage_vec/svec_u16.rs\ndeleted file mode 100644\nindex a1df60ad977..00000000000\n--- a/test/src/sdk-harness/test_projects/storage_vec/svec_u16.rs\n+++ /dev/null\n@@ -1,11 +0,0 @@\n-testgen!(\n- test_u16_vec,\n- \"out/svec_u16-abi.json\",\n- \"u16\",\n- u16,\n- 1u16,\n- 2u16,\n- 3u16,\n- 4u16,\n- 5u16\n-);\ndiff --git a/test/src/sdk-harness/test_projects/storage_vec/svec_u32.rs b/test/src/sdk-harness/test_projects/storage_vec/svec_u32.rs\ndeleted file mode 100644\nindex 032eb529ac0..00000000000\n--- a/test/src/sdk-harness/test_projects/storage_vec/svec_u32.rs\n+++ /dev/null\n@@ -1,11 +0,0 @@\n-testgen!(\n- test_u32_vec,\n- \"out/svec_u32-abi.json\",\n- \"u32\",\n- u32,\n- 1u32,\n- 2u32,\n- 3u32,\n- 4u32,\n- 5u32\n-);\ndiff --git a/test/src/sdk-harness/test_projects/storage_vec/svec_u64.rs b/test/src/sdk-harness/test_projects/storage_vec/svec_u64.rs\ndeleted file mode 100644\nindex 32cad0d46f0..00000000000\n--- a/test/src/sdk-harness/test_projects/storage_vec/svec_u64.rs\n+++ /dev/null\n@@ -1,11 +0,0 @@\n-testgen!(\n- test_u64_vec,\n- \"out/svec_u64-abi.json\",\n- \"u64\",\n- u64,\n- 1u64,\n- 2u64,\n- 3u64,\n- 4u64,\n- 5u64\n-);\ndiff --git a/test/src/sdk-harness/test_projects/storage_vec/svec_u8.rs b/test/src/sdk-harness/test_projects/storage_vec/svec_u8.rs\ndeleted file mode 100644\nindex 1cb1f5cc26f..00000000000\n--- a/test/src/sdk-harness/test_projects/storage_vec/svec_u8.rs\n+++ /dev/null\n@@ -1,11 +0,0 @@\n-testgen!(\n- test_u8_vec,\n- \"out/svec_u8-abi.json\",\n- \"u8\",\n- u8,\n- 1u8,\n- 2u8,\n- 3u8,\n- 4u8,\n- 5u8\n-);\ndiff --git a/test/src/sdk-harness/test_projects/storage_vec/testgen.rs b/test/src/sdk-harness/test_projects/storage_vec/testgen.rs\ndeleted file mode 100644\nindex e413655ed35..00000000000\n--- a/test/src/sdk-harness/test_projects/storage_vec/testgen.rs\n+++ /dev/null\n@@ -1,665 +0,0 @@\n-#[macro_export]\n-macro_rules! testgen {\n- (\n- // Name of the module to create.\n- $module_name:ident,\n- // Path to the contract ABI (string literal required for `abigen!`).\n- $abi_path:expr,\n- // Type to test, as a string literal (required for binary and storage file names).\n- $type_label:expr,\n- // Type to test, as a Rust type declaration (required for function signatures).\n- $type_declaration:ty,\n- // Arguments of type `$type_declaration` to use in tests.\n- $arg0:expr,\n- $arg1:expr,\n- $arg2:expr,\n- $arg3:expr,\n- $arg4:expr\n- ) => {\n- pub mod $module_name {\n- use fuels::prelude::*;\n-\n- abigen!(Contract(\n- name = \"MyContract\",\n- abi = $abi_path\n- ));\n-\n- // Silences `super::*` warning; required for user-defined types.\n- #[allow(unused_imports)]\n- pub mod setup {\n- use super::*;\n-\n- pub async fn get_contract_instance() -> MyContract<Wallet> {\n- let wallet = launch_provider_and_get_wallet().await.unwrap();\n- let id = Contract::load_from(\n- &format!(\n- \"out/svec_{}.bin\",\n- $type_label,\n- ),\n- LoadConfiguration::default()\n- .with_storage_configuration(StorageConfiguration::default()\n- .add_slot_overrides_from_file(\n- &format!(\n- \"out/svec_{}-storage_slots.json\",\n- $type_label,\n- )\n- )\n- .unwrap()),\n- )\n- .unwrap()\n- .deploy(&wallet, TxPolicies::default())\n- .await\n- .unwrap()\n- .contract_id;\n-\n- MyContract::new(id.clone(), wallet)\n- }\n- }\n-\n- // Silences `super::*` warning; required for user-defined types.\n- #[allow(unused_imports)]\n- pub mod wrappers {\n- use super::*;\n-\n- pub async fn push(instance: &MyContract<Wallet>, value: $type_declaration) {\n- instance.methods()\n- .push(value)\n- .call()\n- .await\n- .unwrap();\n- }\n-\n- pub async fn pop(instance: &MyContract<Wallet>) -> $type_declaration {\n- instance.methods()\n- .pop()\n- .call()\n- .await\n- .unwrap()\n- .value\n- }\n-\n- pub async fn get(instance: &MyContract<Wallet>, index: u64) -> $type_declaration {\n- instance.methods()\n- .get(index)\n- .call()\n- .await\n- .unwrap()\n- .value\n- }\n-\n- pub async fn remove(instance: &MyContract<Wallet>, index: u64) -> $type_declaration {\n- instance.methods()\n- .remove(index)\n- .call()\n- .await\n- .unwrap()\n- .value\n- }\n-\n- pub async fn swap_remove(instance: &MyContract<Wallet>, index: u64) -> $type_declaration {\n- instance.methods()\n- .swap_remove(index)\n- .call()\n- .await\n- .unwrap()\n- .value\n- }\n-\n- pub async fn set(instance: &MyContract<Wallet>, index: u64, value: $type_declaration) {\n- instance.methods()\n- .set(index, value)\n- .call()\n- .await\n- .unwrap();\n- }\n-\n- pub async fn insert(instance: &MyContract<Wallet>, index: u64, value: $type_declaration) {\n- instance.methods()\n- .insert(index, value)\n- .call()\n- .await\n- .unwrap();\n- }\n-\n- pub async fn len(instance: &MyContract<Wallet>) -> u64 {\n- instance.methods()\n- .len()\n- .call()\n- .await\n- .unwrap()\n- .value\n- }\n-\n- pub async fn is_empty(instance: &MyContract<Wallet>) -> bool {\n- instance.methods()\n- .is_empty()\n- .call()\n- .await\n- .unwrap()\n- .value\n- }\n-\n- pub async fn clear(instance: &MyContract<Wallet>) {\n- instance.methods()\n- .clear()\n- .call()\n- .await\n- .unwrap();\n- }\n-\n- pub async fn swap(instance: &MyContract<Wallet>, index_0: u64, index_1: u64) {\n- instance.methods()\n- .swap(index_0, index_1)\n- .call()\n- .await\n- .unwrap();\n- }\n-\n- pub async fn first(instance: &MyContract<Wallet>) -> $type_declaration {\n- instance.methods()\n- .first()\n- .call()\n- .await\n- .unwrap()\n- .value\n- }\n-\n- pub async fn last(instance: &MyContract<Wallet>) -> $type_declaration {\n- instance.methods()\n- .last()\n- .call()\n- .await\n- .unwrap()\n- .value\n- }\n-\n- pub async fn reverse(instance: &MyContract<Wallet>) {\n- instance.methods()\n- .reverse()\n- .call()\n- .await\n- .unwrap();\n- }\n-\n- pub async fn fill(instance: &MyContract<Wallet>, value: $type_declaration) {\n- instance.methods()\n- .fill(value)\n- .call()\n- .await\n- .unwrap();\n- }\n-\n- pub async fn resize(instance: &MyContract<Wallet>, new_len: u64, value: $type_declaration) {\n- instance.methods()\n- .resize(new_len, value)\n- .call()\n- .await\n- .unwrap();\n- }\n- }\n-\n- // Silences `super::*` warning; required for user-defined types.\n- #[allow(unused_imports)]\n- pub mod success {\n- use super::{\n- *,\n- setup::get_contract_instance,\n- wrappers::*,\n- };\n-\n- #[tokio::test]\n- async fn can_push() {\n- let instance = get_contract_instance().await;\n-\n- push(&instance, $arg0).await;\n-\n- assert_eq!(get(&instance, 0).await, $arg0);\n- assert_eq!(len(&instance).await, 1);\n- }\n-\n- #[tokio::test]\n- async fn can_pop() {\n- let instance = get_contract_instance().await;\n-\n- push(&instance, $arg0).await;\n-\n- assert_eq!(len(&instance).await, 1);\n- assert_eq!(get(&instance, 0).await, $arg0);\n- assert_eq!(pop(&instance).await, $arg0);\n- assert_eq!(len(&instance).await, 0);\n- }\n-\n- #[tokio::test]\n- async fn can_get() {\n- let instance = get_contract_instance().await;\n-\n- push(&instance, $arg0).await;\n-\n- assert_eq!(get(&instance, 0).await, $arg0);\n- }\n-\n- #[tokio::test]\n- async fn can_remove() {\n- let instance = get_contract_instance().await;\n-\n- push(&instance, $arg0).await;\n- push(&instance, $arg1).await;\n- push(&instance, $arg2).await;\n- push(&instance, $arg3).await;\n-\n- assert_eq!(len(&instance).await, 4);\n- assert_eq!(get(&instance, 0).await, $arg0);\n- assert_eq!(get(&instance, 1).await, $arg1);\n- assert_eq!(get(&instance, 2).await, $arg2);\n- assert_eq!(get(&instance, 3).await, $arg3);\n-\n- assert_eq!(remove(&instance, 2).await, $arg2);\n-\n- assert_eq!(len(&instance).await, 3);\n- assert_eq!(get(&instance, 0).await, $arg0);\n- assert_eq!(get(&instance, 1).await, $arg1);\n- assert_eq!(get(&instance, 2).await, $arg3);\n- }\n-\n- #[tokio::test]\n- async fn can_swap_remove() {\n- let instance = get_contract_instance().await;\n-\n- push(&instance, $arg0).await;\n- push(&instance, $arg1).await;\n- push(&instance, $arg2).await;\n- push(&instance, $arg3).await;\n-\n- assert_eq!(len(&instance).await, 4);\n- assert_eq!(get(&instance, 0).await, $arg0);\n- assert_eq!(get(&instance, 1).await, $arg1);\n- assert_eq!(get(&instance, 2).await, $arg2);\n- assert_eq!(get(&instance, 3).await, $arg3);\n-\n- assert_eq!(swap_remove(&instance, 1).await, $arg1);\n-\n- assert_eq!(len(&instance).await, 3);\n- assert_eq!(get(&instance, 0).await, $arg0);\n- assert_eq!(get(&instance, 1).await, $arg3);\n- assert_eq!(get(&instance, 2).await, $arg2);\n- }\n-\n- #[tokio::test]\n- async fn can_set() {\n- let instance = get_contract_instance().await;\n-\n- push(&instance, $arg0).await;\n- push(&instance, $arg1).await;\n- push(&instance, $arg2).await;\n- push(&instance, $arg3).await;\n-\n- assert_eq!(len(&instance).await, 4);\n- assert_eq!(get(&instance, 0).await, $arg0);\n- assert_eq!(get(&instance, 1).await, $arg1);\n- assert_eq!(get(&instance, 2).await, $arg2);\n- assert_eq!(get(&instance, 3).await, $arg3);\n-\n- set(&instance, 0, $arg3).await;\n- set(&instance, 1, $arg2).await;\n- set(&instance, 2, $arg1).await;\n- set(&instance, 3, $arg0).await;\n-\n- assert_eq!(get(&instance, 0).await, $arg3);\n- assert_eq!(get(&instance, 1).await, $arg2);\n- assert_eq!(get(&instance, 2).await, $arg1);\n- assert_eq!(get(&instance, 3).await, $arg0);\n- }\n-\n- #[tokio::test]\n- async fn can_insert() {\n- let instance = get_contract_instance().await;\n-\n- insert(&instance, 0, $arg0).await;\n-\n- assert_eq!(len(&instance).await, 1);\n- assert_eq!(get(&instance, 0).await, $arg0);\n-\n- push(&instance, $arg1).await;\n- push(&instance, $arg2).await;\n- push(&instance, $arg3).await;\n-\n- assert_eq!(len(&instance).await, 4);\n- assert_eq!(get(&instance, 0).await, $arg0);\n- assert_eq!(get(&instance, 1).await, $arg1);\n- assert_eq!(get(&instance, 2).await, $arg2);\n- assert_eq!(get(&instance, 3).await, $arg3);\n-\n- insert(&instance, 1, $arg4).await;\n-\n- assert_eq!(len(&instance).await, 5);\n- assert_eq!(get(&instance, 0).await, $arg0);\n- assert_eq!(get(&instance, 1).await, $arg4);\n- assert_eq!(get(&instance, 2).await, $arg1);\n- assert_eq!(get(&instance, 3).await, $arg2);\n- assert_eq!(get(&instance, 4).await, $arg3);\n- }\n-\n- #[tokio::test]\n- async fn can_get_len() {\n- let instance = get_contract_instance().await;\n-\n- assert_eq!(len(&instance).await, 0);\n-\n- push(&instance, $arg0).await;\n-\n- assert_eq!(len(&instance).await, 1);\n-\n- push(&instance, $arg1).await;\n-\n- assert_eq!(len(&instance).await, 2);\n- }\n-\n- #[tokio::test]\n- async fn can_confirm_emptiness() {\n- let instance = get_contract_instance().await;\n-\n- assert!(is_empty(&instance).await);\n-\n- push(&instance, $arg0).await;\n-\n- assert!(!is_empty(&instance).await);\n-\n- clear(&instance).await;\n-\n- assert!(is_empty(&instance).await);\n- }\n-\n- #[tokio::test]\n- async fn can_clear() {\n- let instance = get_contract_instance().await;\n-\n- push(&instance, $arg0).await;\n-\n- assert!(!is_empty(&instance).await);\n-\n- clear(&instance).await;\n-\n- assert!(is_empty(&instance).await);\n-\n- push(&instance, $arg0).await;\n- push(&instance, $arg1).await;\n- push(&instance, $arg2).await;\n- push(&instance, $arg3).await;\n-\n- assert!(!is_empty(&instance).await);\n-\n- clear(&instance).await;\n-\n- assert!(is_empty(&instance).await);\n- }\n-\n- #[tokio::test]\n- async fn can_swap() {\n- let instance = get_contract_instance().await;\n-\n- push(&instance, $arg0).await;\n- push(&instance, $arg1).await;\n- push(&instance, $arg2).await;\n- push(&instance, $arg3).await;\n-\n- assert_eq!(len(&instance).await, 4);\n- assert_eq!(get(&instance, 0).await, $arg0);\n- assert_eq!(get(&instance, 1).await, $arg1);\n- assert_eq!(get(&instance, 2).await, $arg2);\n- assert_eq!(get(&instance, 3).await, $arg3);\n- swap(&instance, 0, 3).await;\n- swap(&instance, 1, 2).await;\n-\n- assert_eq!(get(&instance, 0).await, $arg3);\n- assert_eq!(get(&instance, 1).await, $arg2);\n- assert_eq!(get(&instance, 2).await, $arg1);\n- assert_eq!(get(&instance, 3).await, $arg0);\n- }\n-\n- #[tokio::test]\n- async fn can_get_first() {\n- let instance = get_contract_instance().await;\n-\n- push(&instance, $arg0).await;\n- push(&instance, $arg1).await;\n-\n- assert_eq!(len(&instance).await, 2);\n- assert_eq!(get(&instance, 0).await, $arg0);\n- assert_eq!(get(&instance, 1).await, $arg1);\n-\n- assert_eq!(first(&instance).await, $arg0);\n- }\n-\n- #[tokio::test]\n- async fn can_get_last() {\n- let instance = get_contract_instance().await;\n-\n- push(&instance, $arg0).await;\n- push(&instance, $arg1).await;\n-\n- assert_eq!(len(&instance).await, 2);\n- assert_eq!(get(&instance, 0).await, $arg0);\n- assert_eq!(get(&instance, 1).await, $arg1);\n- assert_eq!(last(&instance).await, $arg1);\n- }\n-\n- #[tokio::test]\n- async fn can_reverse_even_len() {\n- let instance = get_contract_instance().await;\n-\n- push(&instance, $arg0).await;\n- push(&instance, $arg1).await;\n- push(&instance, $arg2).await;\n- push(&instance, $arg3).await;\n-\n- assert_eq!(len(&instance).await, 4);\n- assert_eq!(get(&instance, 0).await, $arg0);\n- assert_eq!(get(&instance, 1).await, $arg1);\n- assert_eq!(get(&instance, 2).await, $arg2);\n- assert_eq!(get(&instance, 3).await, $arg3);\n-\n- reverse(&instance).await;\n-\n- assert_eq!(len(&instance).await, 4);\n- assert_eq!(get(&instance, 0).await, $arg3);\n- assert_eq!(get(&instance, 1).await, $arg2);\n- assert_eq!(get(&instance, 2).await, $arg1);\n- assert_eq!(get(&instance, 3).await, $arg0);\n-\n- reverse(&instance).await;\n-\n- assert_eq!(len(&instance).await, 4);\n- assert_eq!(get(&instance, 0).await, $arg0);\n- assert_eq!(get(&instance, 1).await, $arg1);\n- assert_eq!(get(&instance, 2).await, $arg2);\n- assert_eq!(get(&instance, 3).await, $arg3);\n- }\n-\n- #[tokio::test]\n- async fn can_reverse_odd_len() {\n- let instance = get_contract_instance().await;\n-\n- push(&instance, $arg0).await;\n- push(&instance, $arg1).await;\n- push(&instance, $arg2).await;\n-\n- assert_eq!(len(&instance).await, 3);\n- assert_eq!(get(&instance, 0).await, $arg0);\n- assert_eq!(get(&instance, 1).await, $arg1);\n- assert_eq!(get(&instance, 2).await, $arg2);\n-\n- reverse(&instance).await;\n-\n- assert_eq!(len(&instance).await, 3);\n-\n- assert_eq!(get(&instance, 0).await, $arg2);\n- assert_eq!(get(&instance, 1).await, $arg1);\n- assert_eq!(get(&instance, 2).await, $arg0);\n-\n- reverse(&instance).await;\n-\n- assert_eq!(len(&instance).await, 3);\n- assert_eq!(get(&instance, 0).await, $arg0);\n- assert_eq!(get(&instance, 1).await, $arg1);\n- assert_eq!(get(&instance, 2).await, $arg2);\n- }\n-\n- #[tokio::test]\n- async fn can_fill() {\n- let instance = get_contract_instance().await;\n-\n- push(&instance, $arg0).await;\n- push(&instance, $arg1).await;\n- push(&instance, $arg2).await;\n- push(&instance, $arg3).await;\n-\n- assert_eq!(len(&instance).await, 4);\n- assert_eq!(get(&instance, 0).await, $arg0);\n- assert_eq!(get(&instance, 1).await, $arg1);\n- assert_eq!(get(&instance, 2).await, $arg2);\n- assert_eq!(get(&instance, 3).await, $arg3);\n-\n- fill(&instance, $arg4).await;\n-\n- assert_eq!(len(&instance).await, 4);\n- assert_eq!(get(&instance, 0).await, $arg4);\n- assert_eq!(get(&instance, 1).await, $arg4);\n- assert_eq!(get(&instance, 2).await, $arg4);\n- assert_eq!(get(&instance, 3).await, $arg4);\n- }\n-\n- #[tokio::test]\n- async fn can_resize_up() {\n- let instance = get_contract_instance().await;\n-\n- push(&instance, $arg0).await;\n- push(&instance, $arg1).await;\n- push(&instance, $arg2).await;\n- push(&instance, $arg3).await;\n-\n- assert_eq!(len(&instance).await, 4);\n- assert_eq!(get(&instance, 0).await, $arg0);\n- assert_eq!(get(&instance, 1).await, $arg1);\n- assert_eq!(get(&instance, 2).await, $arg2);\n- assert_eq!(get(&instance, 3).await, $arg3);\n-\n- resize(&instance, 6, $arg4).await;\n-\n- assert_eq!(len(&instance).await, 6);\n- assert_eq!(get(&instance, 0).await, $arg0);\n- assert_eq!(get(&instance, 1).await, $arg1);\n- assert_eq!(get(&instance, 2).await, $arg2);\n- assert_eq!(get(&instance, 3).await, $arg3);\n- assert_eq!(get(&instance, 4).await, $arg4);\n- assert_eq!(get(&instance, 5).await, $arg4);\n- }\n-\n- #[tokio::test]\n- async fn can_resize_down() {\n- let instance = get_contract_instance().await;\n-\n- push(&instance, $arg0).await;\n- push(&instance, $arg1).await;\n- push(&instance, $arg2).await;\n- push(&instance, $arg3).await;\n-\n- assert_eq!(len(&instance).await, 4);\n- assert_eq!(get(&instance, 0).await, $arg0);\n- assert_eq!(get(&instance, 1).await, $arg1);\n- assert_eq!(get(&instance, 2).await, $arg2);\n- assert_eq!(get(&instance, 3).await, $arg3);\n-\n- resize(&instance, 2, $arg4).await;\n-\n- assert_eq!(len(&instance).await, 2);\n- assert_eq!(get(&instance, 0).await, $arg0);\n- assert_eq!(get(&instance, 1).await, $arg1);\n- }\n- }\n-\n- // Silences `super::*` warning; required for user-defined types.\n- #[allow(unused_imports)]\n- pub mod failure {\n- use super::{\n- *,\n- setup::get_contract_instance,\n- wrappers::*,\n- };\n-\n- #[tokio::test]\n- #[should_panic(expected = \"revert_id: Some(0)\")]\n- async fn cant_pop() {\n- let instance = get_contract_instance().await;\n-\n- let _ = pop(&instance).await;\n- }\n-\n- #[tokio::test]\n- #[should_panic(expected = \"revert_id: Some(0)\")]\n- async fn cant_get() {\n- let instance = get_contract_instance().await;\n-\n- get(&instance, 0).await;\n- }\n-\n- #[tokio::test]\n- #[should_panic(expected = \"revert_id: Some(18446744073709486084)\")]\n- async fn cant_remove() {\n- let instance = get_contract_instance().await;\n-\n- let _ = remove(&instance, 0).await;\n- }\n-\n- #[tokio::test]\n- #[should_panic(expected = \"revert_id: Some(18446744073709486084)\")]\n- async fn cant_swap_remove() {\n- let instance = get_contract_instance().await;\n-\n- let _ = swap_remove(&instance, 0).await;\n- }\n-\n- #[tokio::test]\n- #[should_panic(expected = \"revert_id: Some(18446744073709486084)\")]\n- async fn cant_set() {\n- let instance = get_contract_instance().await;\n-\n- set(&instance, 1, $arg1).await;\n- }\n-\n- #[tokio::test]\n- #[should_panic(expected = \"revert_id: Some(18446744073709486084)\")]\n- async fn cant_insert() {\n- let instance = get_contract_instance().await;\n-\n- insert(&instance, 1, $arg1).await;\n- }\n-\n- #[tokio::test]\n- #[should_panic(expected = \"revert_id: Some(0)\")]\n- async fn cant_get_first() {\n- let instance = get_contract_instance().await;\n-\n- let _ = first(&instance).await;\n- }\n-\n- #[tokio::test]\n- #[should_panic(expected = \"revert_id: Some(0)\")]\n- async fn cant_get_last() {\n- let instance = get_contract_instance().await;\n-\n- let _ = last(&instance).await;\n- }\n-\n-\n- #[tokio::test]\n- #[should_panic(expected = \"revert_id: Some(18446744073709486084)\")]\n- async fn cant_swap() {\n- let instance = get_contract_instance().await;\n-\n- let _ = swap(&instance, 0, 1).await;\n- }\n- }\n-\n- }\n- }\n-}\ndiff --git a/test/src/sdk-harness/test_projects/storage_vec_nested/Forc.lock b/test/src/sdk-harness/test_projects/storage_vec_nested/Forc.lock\ndeleted file mode 100644\nindex b1118d9c766..00000000000\n--- a/test/src/sdk-harness/test_projects/storage_vec_nested/Forc.lock\n+++ /dev/null\n@@ -1,13 +0,0 @@\n-[[package]]\n-name = 'core'\n-source = 'path+from-root-0A73F145D8D4FEED'\n-\n-[[package]]\n-name = 'std'\n-source = 'path+from-root-0A73F145D8D4FEED'\n-dependencies = ['core']\n-\n-[[package]]\n-name = 'storage_vec_nested'\n-source = 'member'\n-dependencies = ['std']\ndiff --git a/test/src/sdk-harness/test_projects/storage_vec_nested/mod.rs b/test/src/sdk-harness/test_projects/storage_vec_nested/mod.rs\ndeleted file mode 100644\nindex c9e97e27115..00000000000\n--- a/test/src/sdk-harness/test_projects/storage_vec_nested/mod.rs\n+++ /dev/null\n@@ -1,43 +0,0 @@\n-use fuels::prelude::*;\n-\n-abigen!(Contract(\n- name = \"TestStorageVecNestedContract\",\n- abi = \"out/storage_vec_nested-abi.json\",\n-));\n-\n-async fn test_storage_vec_nested_instance() -> TestStorageVecNestedContract<Wallet> {\n- let wallet = launch_provider_and_get_wallet().await.unwrap();\n- let id = Contract::load_from(\n- \"out/storage_vec_nested.bin\",\n- LoadConfiguration::default(),\n- )\n- .unwrap()\n- .deploy(&wallet, TxPolicies::default())\n- .await\n- .unwrap()\n- .contract_id;\n-\n- TestStorageVecNestedContract::new(id.clone(), wallet)\n-}\n-\n-#[tokio::test]\n-async fn nested_vec_access_push() {\n- let methods = test_storage_vec_nested_instance().await.methods();\n-\n- methods.nested_vec_access_push().call().await.unwrap();\n-}\n-\n-#[tokio::test]\n-async fn nested_vec_access_insert() {\n- let methods = test_storage_vec_nested_instance().await.methods();\n-\n- methods.nested_vec_access_insert().call().await.unwrap();\n-}\n-\n-#[tokio::test]\n-#[should_panic]\n-async fn revert_on_load_storage_vec() {\n- let methods = test_storage_vec_nested_instance().await.methods();\n-\n- methods.revert_on_load_storage_vec().call().await.unwrap();\n-}\ndiff --git a/test/src/sdk-harness/test_projects/storage_vec_nested/src/main.sw b/test/src/sdk-harness/test_projects/storage_vec_nested/src/main.sw\ndeleted file mode 100644\nindex 122682a6a47..00000000000\n--- a/test/src/sdk-harness/test_projects/storage_vec_nested/src/main.sw\n+++ /dev/null\n@@ -1,107 +0,0 @@\n-contract;\n-\n-use std::storage::storage_vec::*;\n-\n-storage {\n- nested_vec: StorageVec<StorageVec<u64>> = StorageVec {},\n-}\n-\n-abi ExperimentalStorageTest {\n- #[storage(read, write)]\n- fn nested_vec_access_push();\n-\n- #[storage(read, write)]\n- fn nested_vec_access_insert();\n-\n- #[storage(read, write)]\n- fn revert_on_load_storage_vec();\n-}\n-\n-impl ExperimentalStorageTest for Contract {\n- #[storage(read, write)]\n- fn nested_vec_access_push() {\n- storage.nested_vec.push(StorageVec {});\n- storage.nested_vec.push(StorageVec {});\n- storage.nested_vec.push(StorageVec {});\n-\n- let mut inner_vec0 = storage.nested_vec.get(0).unwrap();\n- let mut inner_vec1 = storage.nested_vec.get(1).unwrap();\n- let mut inner_vec2 = storage.nested_vec.get(2).unwrap();\n-\n- assert(storage.nested_vec.len() == 3);\n- assert(storage.nested_vec.get(3).is_none());\n-\n- test_access(inner_vec0, inner_vec1, inner_vec2);\n- }\n-\n- #[storage(read, write)]\n- fn nested_vec_access_insert() {\n- // TODO: Uncomment this test once https://github.com/FuelLabs/sway/issues/6040 is fixed.\n- // storage.nested_vec.insert(0, StorageVec {});\n- // storage.nested_vec.insert(0, StorageVec {});\n- // storage.nested_vec.insert(0, StorageVec {});\n-\n- // let mut inner_vec0 = storage.nested_vec.get(0).unwrap();\n- // let mut inner_vec1 = storage.nested_vec.get(1).unwrap();\n- // let mut inner_vec2 = storage.nested_vec.get(2).unwrap();\n-\n- // assert(storage.nested_vec.len() == 3);\n- // assert(storage.nested_vec.get(3).is_none());\n-\n- // test_access(inner_vec0, inner_vec1, inner_vec2);\n- }\n-\n- #[storage(read, write)]\n- fn revert_on_load_storage_vec() {\n- storage.nested_vec.push(StorageVec {});\n- storage.nested_vec.push(StorageVec {});\n- storage.nested_vec.push(StorageVec {});\n-\n- let _ =storage.nested_vec.load_vec();\n- }\n-}\n-\n-#[storage(read, write)]\n-fn test_access(inner_vec0: StorageKey<StorageVec<u64>>, inner_vec1: StorageKey<StorageVec<u64>>, inner_vec2: StorageKey<StorageVec<u64>>) {\n- inner_vec0.push(0);\n- inner_vec0.push(1);\n-\n- inner_vec1.push(2);\n- inner_vec1.push(3);\n- inner_vec1.push(4);\n-\n- inner_vec2.push(5);\n- inner_vec2.push(6);\n- inner_vec2.push(7);\n- inner_vec2.push(8);\n-\n- inner_vec0.set(0, 0);\n- inner_vec0.set(1, 11);\n-\n- inner_vec1.set(0, 22);\n- inner_vec1.set(1, 33);\n- inner_vec1.set(2, 44);\n-\n- inner_vec2.set(0, 55);\n- inner_vec2.set(1, 66);\n- inner_vec2.set(2, 77);\n- inner_vec2.set(3, 88);\n-\n- assert(inner_vec0.len() == 2);\n- assert(inner_vec0.get(0).unwrap().read() == 0);\n- assert(inner_vec0.get(1).unwrap().read() == 11);\n- assert(inner_vec0.get(2).is_none());\n-\n- assert(inner_vec1.len() == 3);\n- assert(inner_vec1.get(0).unwrap().read() == 22);\n- assert(inner_vec1.get(1).unwrap().read() == 33);\n- assert(inner_vec1.get(2).unwrap().read() == 44);\n- assert(inner_vec1.get(3).is_none());\n-\n- assert(inner_vec2.len() == 4);\n- assert(inner_vec2.get(0).unwrap().read() == 55);\n- assert(inner_vec2.get(1).unwrap().read() == 66);\n- assert(inner_vec2.get(2).unwrap().read() == 77);\n- assert(inner_vec2.get(3).unwrap().read() == 88);\n- assert(inner_vec2.get(4).is_none());\n-}\n\\ No newline at end of file\ndiff --git a/test/src/sdk-harness/test_projects/storage_vec_to_vec/Forc.lock b/test/src/sdk-harness/test_projects/storage_vec_to_vec/Forc.lock\ndeleted file mode 100644\nindex 3595c5dae85..00000000000\n--- a/test/src/sdk-harness/test_projects/storage_vec_to_vec/Forc.lock\n+++ /dev/null\n@@ -1,8 +0,0 @@\n-[[package]]\n-name = \"std\"\n-source = \"path+from-root-2B98DB2C67784422\"\n-\n-[[package]]\n-name = \"storage_vec_to_vec\"\n-source = \"member\"\n-dependencies = [\"std\"]\ndiff --git a/test/src/sdk-harness/test_projects/storage_vec_to_vec/mod.rs b/test/src/sdk-harness/test_projects/storage_vec_to_vec/mod.rs\ndeleted file mode 100644\nindex ac6aea1f948..00000000000\n--- a/test/src/sdk-harness/test_projects/storage_vec_to_vec/mod.rs\n+++ /dev/null\n@@ -1,338 +0,0 @@\n-use fuels::prelude::*;\n-\n-abigen!(Contract(\n- name = \"TestStorageVecToVecContract\",\n- abi = \"out/storage_vec_to_vec-abi.json\",\n-));\n-\n-async fn test_storage_vec_to_vec_instance() -> TestStorageVecToVecContract<Wallet> {\n- let wallet = launch_provider_and_get_wallet().await.unwrap();\n- let id = Contract::load_from(\n- \"out/storage_vec_to_vec.bin\",\n- LoadConfiguration::default(),\n- )\n- .unwrap()\n- .deploy(&wallet, TxPolicies::default())\n- .await\n- .unwrap()\n- .contract_id;\n-\n- TestStorageVecToVecContract::new(id.clone(), wallet)\n-}\n-\n-#[tokio::test]\n-async fn test_conversion_u64() {\n- let instance = test_storage_vec_to_vec_instance().await;\n-\n- let test_vec = vec![5, 7, 9, 11];\n-\n- let _ = instance\n- .methods()\n- .store_vec_u64(test_vec.clone())\n- .call()\n- .await;\n-\n- let returned_vec = instance\n- .methods()\n- .read_vec_u64()\n- .call()\n- .await\n- .unwrap()\n- .value;\n-\n- assert_eq!(returned_vec.len(), 4);\n- assert_eq!(returned_vec, test_vec);\n-}\n-\n-#[tokio::test]\n-async fn test_push_u64() {\n- let instance = test_storage_vec_to_vec_instance().await;\n-\n- let test_vec = vec![5, 7, 9, 11];\n-\n- let _ = instance\n- .methods()\n- .store_vec_u64(test_vec.clone())\n- .call()\n- .await;\n-\n- let _ = instance.methods().push_vec_u64(13).call().await;\n-\n- let returned_vec = instance\n- .methods()\n- .read_vec_u64()\n- .call()\n- .await\n- .unwrap()\n- .value;\n-\n- let mut expected_vec = test_vec;\n- expected_vec.push(13);\n-\n- assert_eq!(returned_vec.len(), 5);\n- assert_eq!(returned_vec, expected_vec);\n-}\n-\n-#[tokio::test]\n-async fn test_pop_u64() {\n- let instance = test_storage_vec_to_vec_instance().await;\n-\n- let test_vec = vec![5, 7, 9, 11];\n-\n- let _ = instance\n- .methods()\n- .store_vec_u64(test_vec.clone())\n- .call()\n- .await;\n-\n- assert_eq!(\n- 11,\n- instance.methods().pop_vec_u64().call().await.unwrap().value\n- );\n-\n- let returned_vec = instance\n- .methods()\n- .read_vec_u64()\n- .call()\n- .await\n- .unwrap()\n- .value;\n-\n- let mut expected_vec = test_vec;\n- expected_vec.pop();\n-\n- assert_eq!(returned_vec.len(), 3);\n- assert_eq!(returned_vec, expected_vec);\n-}\n-\n-#[tokio::test]\n-async fn test_conversion_struct() {\n- let instance = test_storage_vec_to_vec_instance().await;\n-\n- let test_vec = vec![\n- TestStruct {\n- val_1: 0,\n- val_2: 1,\n- val_3: 2,\n- },\n- TestStruct {\n- val_1: 1,\n- val_2: 2,\n- val_3: 3,\n- },\n- TestStruct {\n- val_1: 2,\n- val_2: 3,\n- val_3: 4,\n- },\n- TestStruct {\n- val_1: 3,\n- val_2: 4,\n- val_3: 5,\n- },\n- ];\n-\n- let _ = instance\n- .methods()\n- .store_vec_struct(test_vec.clone())\n- .call()\n- .await;\n-\n- let returned_vec = instance\n- .methods()\n- .read_vec_struct()\n- .call()\n- .await\n- .unwrap()\n- .value;\n-\n- assert_eq!(returned_vec.len(), 4);\n- assert_eq!(returned_vec, test_vec);\n-}\n-\n-#[tokio::test]\n-async fn test_push_struct() {\n- let instance = test_storage_vec_to_vec_instance().await;\n-\n- let test_vec = vec![\n- TestStruct {\n- val_1: 0,\n- val_2: 1,\n- val_3: 2,\n- },\n- TestStruct {\n- val_1: 1,\n- val_2: 2,\n- val_3: 3,\n- },\n- TestStruct {\n- val_1: 2,\n- val_2: 3,\n- val_3: 4,\n- },\n- TestStruct {\n- val_1: 3,\n- val_2: 4,\n- val_3: 5,\n- },\n- ];\n-\n- let test_struct = TestStruct {\n- val_1: 4,\n- val_2: 5,\n- val_3: 6,\n- };\n-\n- let _ = instance\n- .methods()\n- .store_vec_struct(test_vec.clone())\n- .call()\n- .await;\n-\n- let _ = instance\n- .methods()\n- .push_vec_struct(test_struct.clone())\n- .call()\n- .await;\n-\n- let returned_vec = instance\n- .methods()\n- .read_vec_struct()\n- .call()\n- .await\n- .unwrap()\n- .value;\n-\n- let mut expected_vec = test_vec;\n- expected_vec.push(test_struct);\n-\n- assert_eq!(returned_vec.len(), 5);\n- assert_eq!(returned_vec, expected_vec);\n-}\n-\n-#[tokio::test]\n-async fn test_pop_struct() {\n- let instance = test_storage_vec_to_vec_instance().await;\n-\n- let test_struct = TestStruct {\n- val_1: 3,\n- val_2: 4,\n- val_3: 5,\n- };\n- let test_vec = vec![\n- TestStruct {\n- val_1: 0,\n- val_2: 1,\n- val_3: 2,\n- },\n- TestStruct {\n- val_1: 1,\n- val_2: 2,\n- val_3: 3,\n- },\n- TestStruct {\n- val_1: 2,\n- val_2: 3,\n- val_3: 4,\n- },\n- test_struct.clone(),\n- ];\n-\n- let _ = instance\n- .methods()\n- .store_vec_struct(test_vec.clone())\n- .call()\n- .await;\n-\n- assert_eq!(\n- test_struct,\n- instance\n- .methods()\n- .pop_vec_struct()\n- .call()\n- .await\n- .unwrap()\n- .value\n- );\n-\n- let returned_vec = instance\n- .methods()\n- .read_vec_struct()\n- .call()\n- .await\n- .unwrap()\n- .value;\n-\n- let mut expected_vec = test_vec;\n- expected_vec.pop();\n-\n- assert_eq!(returned_vec.len(), 3);\n- assert_eq!(returned_vec, expected_vec);\n-}\n-\n-#[tokio::test]\n-async fn test_conversion_u8() {\n- let instance = test_storage_vec_to_vec_instance().await;\n-\n- let test_vec = vec![5u8, 7u8, 9u8, 11u8];\n-\n- let _ = instance\n- .methods()\n- .store_vec_u8(test_vec.clone())\n- .call()\n- .await;\n-\n- let returned_vec = instance.methods().read_vec_u8().call().await.unwrap().value;\n-\n- assert_eq!(returned_vec.len(), 4);\n- assert_eq!(returned_vec, test_vec);\n-}\n-\n-#[tokio::test]\n-async fn test_push_u8() {\n- let instance = test_storage_vec_to_vec_instance().await;\n-\n- let test_vec = vec![5u8, 7u8, 9u8, 11u8];\n-\n- let _ = instance\n- .methods()\n- .store_vec_u8(test_vec.clone())\n- .call()\n- .await;\n-\n- let _ = instance.methods().push_vec_u8(13u8).call().await;\n-\n- let returned_vec = instance.methods().read_vec_u8().call().await.unwrap().value;\n-\n- let mut expected_vec = test_vec;\n- expected_vec.push(13u8);\n-\n- assert_eq!(returned_vec.len(), 5);\n- assert_eq!(returned_vec, expected_vec);\n-}\n-\n-#[tokio::test]\n-async fn test_pop_u8() {\n- let instance = test_storage_vec_to_vec_instance().await;\n-\n- let test_vec = vec![5u8, 7u8, 9u8, 11u8];\n-\n- let _ = instance\n- .methods()\n- .store_vec_u8(test_vec.clone())\n- .call()\n- .await;\n-\n- assert_eq!(\n- 11u8,\n- instance.methods().pop_vec_u8().call().await.unwrap().value\n- );\n-\n- let returned_vec = instance.methods().read_vec_u8().call().await.unwrap().value;\n-\n- let mut expected_vec = test_vec;\n- expected_vec.pop();\n-\n- assert_eq!(returned_vec.len(), 3);\n- assert_eq!(returned_vec, expected_vec);\n-}\ndiff --git a/test/src/sdk-harness/test_projects/storage_vec_to_vec/src/main.sw b/test/src/sdk-harness/test_projects/storage_vec_to_vec/src/main.sw\ndeleted file mode 100644\nindex 7254afff87d..00000000000\n--- a/test/src/sdk-harness/test_projects/storage_vec_to_vec/src/main.sw\n+++ /dev/null\n@@ -1,115 +0,0 @@\n-contract;\n-\n-use std::storage::storage_vec::*;\n-\n-pub struct TestStruct {\n- val1: u64,\n- val2: u64,\n- val3: u64,\n-}\n-\n-impl PartialEq for TestStruct {\n- fn eq(self, other: Self) -> bool {\n- self.val1 == other.val1 && self.val2 == other.val2 && self.val3 == other.val3\n- }\n-}\n-impl Eq for TestStruct {}\n-\n-storage {\n- storage_vec_u64: StorageVec<u64> = StorageVec {},\n- storage_vec_struct: StorageVec<TestStruct> = StorageVec {},\n- storage_vec_u8: StorageVec<u8> = StorageVec {},\n-}\n-\n-abi VecToVecStorageTest {\n- #[storage(read, write)]\n- fn store_vec_u64(vec: Vec<u64>);\n- #[storage(read)]\n- fn read_vec_u64() -> Vec<u64>;\n- #[storage(read, write)]\n- fn push_vec_u64(val: u64);\n- #[storage(read, write)]\n- fn pop_vec_u64() -> u64;\n- #[storage(read, write)]\n- fn store_vec_struct(vec: Vec<TestStruct>);\n- #[storage(read)]\n- fn read_vec_struct() -> Vec<TestStruct>;\n- #[storage(read, write)]\n- fn push_vec_struct(val: TestStruct);\n- #[storage(read, write)]\n- fn pop_vec_struct() -> TestStruct;\n- #[storage(read, write)]\n- fn store_vec_u8(vec: Vec<u8>);\n- #[storage(read)]\n- fn read_vec_u8() -> Vec<u8>;\n- #[storage(read, write)]\n- fn push_vec_u8(val: u8);\n- #[storage(read, write)]\n- fn pop_vec_u8() -> u8;\n-}\n-\n-impl VecToVecStorageTest for Contract {\n- #[storage(read, write)]\n- fn store_vec_u64(vec: Vec<u64>) {\n- storage.storage_vec_u64.store_vec(vec);\n- }\n-\n- #[storage(read)]\n- fn read_vec_u64() -> Vec<u64> {\n- storage.storage_vec_u64.load_vec()\n- }\n-\n- #[storage(read, write)]\n- fn push_vec_u64(val: u64) {\n- storage.storage_vec_u64.push(val);\n- }\n-\n- #[storage(read, write)]\n- fn pop_vec_u64() -> u64 {\n- storage.storage_vec_u64.pop().unwrap_or(0)\n- }\n-\n- #[storage(read, write)]\n- fn store_vec_struct(vec: Vec<TestStruct>) {\n- storage.storage_vec_struct.store_vec(vec);\n- }\n-\n- #[storage(read)]\n- fn read_vec_struct() -> Vec<TestStruct> {\n- storage.storage_vec_struct.load_vec()\n- }\n-\n- #[storage(read, write)]\n- fn push_vec_struct(val: TestStruct) {\n- storage.storage_vec_struct.push(val);\n- }\n-\n- #[storage(read, write)]\n- fn pop_vec_struct() -> TestStruct {\n- storage.storage_vec_struct.pop().unwrap_or(TestStruct {\n- val1: 0,\n- val2: 0,\n- val3: 0,\n- })\n- }\n-\n- #[storage(read, write)]\n- fn store_vec_u8(vec: Vec<u8>) {\n- storage.storage_vec_u8.store_vec(vec);\n- }\n-\n- #[storage(read)]\n- fn read_vec_u8() -> Vec<u8> {\n- storage.storage_vec_u8.load_vec()\n- }\n-\n- #[storage(read, write)]\n- fn push_vec_u8(val: u8) {\n- storage.storage_vec_u8.push(val);\n- }\n-\n- #[storage(read, write)]\n- fn pop_vec_u8() -> u8 {\n- storage.storage_vec_u8.pop().unwrap_or(0)\n- }\n-}\ndiff --git a/test/src/test_consistency.rs b/test/src/test_consistency.rs\nindex a7459bfb325..5b2cb808945 100644\n--- a/test/src/test_consistency.rs\n+++ b/test/src/test_consistency.rs\n@@ -76,7 +76,7 @@ fn check_forc_tomls(all_tests_dir: &Path) -> Result<()> {\n let toml = content.parse::<Table>().unwrap();\n \n // Skip over workspace configs. We want to test only project configs.\n- if content.starts_with(\"[workspace]\") {\n+ if toml.contains_key(\"workspace\") {\n continue;\n }\n \n"},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":4098,"cells":{"repo":{"kind":"string","value":"FuelLabs/sway"},"pr_number":{"kind":"number","value":7614,"string":"7,614"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"Implement dynamic storage based `StorageVec`"},"pr_body":{"kind":"string","value":"### Test verification uses wrong split point for expected sequence\n\n**Low Severity**\n\n<!-- DESCRIPTION START -->\nThe expected sequence construction in `assert_insert_impl` uses `middle_index` (which is an index into the *vector* after front insertion) as a split point into `expected_values`. After the front insert, original elements are shifted right by one, so `vec[6]` holds `ev[5]`. The loop `while i < middle_index` pushes `ev[0]` through `ev[5]`, then `inserted_middle`, then `ev[6]` onward. But the actual vector has `inserted_middle` at position 6 and `ev[5]` at position 7. The test passes only because `inserted_middle = expected_values.get(NUM_OF_ELEMENTS / 2) = ev[5]`, which is identical to the displaced element. The correct split should be `middle_index - 1` elements from `expected_values` before `inserted_middle`.\n<!-- DESCRIPTION END -->\n\n<!-- BUGBOT_BUG_ID: 1cd43340-fda3-4fe5-bb9c-d67146c7ccc3 -->\n\n<!-- LOCATIONS START\ntest/src/in_language_tests/test_programs/storage_vec_insert_contract_tests/src/main.sw#L77-L90\nLOCATIONS END -->\n<div><a href=\"https://cursor.com/open?data=eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsImtpZCI6ImJ1Z2JvdC12MiJ9.eyJ2ZXJzaW9uIjoxLCJ0eXBlIjoiQlVHQk9UX0ZJWF9JTl9DVVJTT1IiLCJkYXRhIjp7InJlZGlzS2V5IjoiYnVnYm90OmQwMDY4ODg5LTNmNTktNDkzZS1hNWM1LThlYTNkOTM2N2VlMyIsImVuY3J5cHRpb25LZXkiOiJBd25BZjc4YS1ycDBuTklhSzBhaTFYQUljaFpHbkhLUGtTU1dDSWg1NDdzIiwiYnJhbmNoIjoiaXJvbmNldi9keW5hbWljLXN0b3JhZ2Utc3RvcmFnZS12ZWMiLCJyZXBvT3duZXIiOiJGdWVsTGFicyIsInJlcG9OYW1lIjoic3dheSJ9LCJpYXQiOjE3Nzc1NDY3MTIsImV4cCI6MTc4MDEzODcxMn0.cspHKtWTETEOXvIWcb-4C9PDYhhDnlG02hblWALfjNw9uOmapdzbKdm4tLfgqGYycZ16bBTPAHh-5S9aUl7r1NPEbxr3AfbwYaizwYH9rvJSZNYn0hpJ9qC4Olr_wZoE2kHcspzcWGfPk34pMEkXV1-SqIiGvpd7fnokjn8FD1HOsrULA9D655z2psr8YQRyZqsxVcxq3uFGMpIiU7dMnYO7cD6YEE5Elk9TyckUXT9qGkkY_KPOP6q7N4hiBh0w12VbJK_IEC4avCGkynYnfpSJQcTyOv4HNoaGYH-mQYp1uAvr9ecMs3PDb0xqXy98-ZBuPbXGqgfDeP5wKbr1Dw\" target=\"_blank\" rel=\"noopener noreferrer\"><picture><source media=\"(prefers-color-scheme: dark)\" srcset=\"https://cursor.com/assets/images/fix-in-cursor-dark.png\"><source media=\"(prefers-color-scheme: light)\" srcset=\"https://cursor.com/assets/images/fix-in-cursor-light.png\"><img alt=\"Fix in Cursor\" width=\"115\" height=\"28\" src=\"https://cursor.com/assets/images/fix-in-cursor-dark.png\"></picture></a> <a href=\"https://cursor.com/agents?data=eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsImtpZCI6ImJ1Z2JvdC12MiJ9.eyJ2ZXJzaW9uIjoxLCJ0eXBlIjoiQlVHQk9UX0ZJWF9JTl9XRUIiLCJkYXRhIjp7InJlZGlzS2V5IjoiYnVnYm90OmQwMDY4ODg5LTNmNTktNDkzZS1hNWM1LThlYTNkOTM2N2VlMyIsImVuY3J5cHRpb25LZXkiOiJBd25BZjc4YS1ycDBuTklhSzBhaTFYQUljaFpHbkhLUGtTU1dDSWg1NDdzIiwiYnJhbmNoIjoiaXJvbmNldi9keW5hbWljLXN0b3JhZ2Utc3RvcmFnZS12ZWMiLCJyZXBvT3duZXIiOiJGdWVsTGFicyIsInJlcG9OYW1lIjoic3dheSIsInByTnVtYmVyIjo3NjE0LCJjb21taXRTaGEiOiIwMGZmOTYwNjgzOGE3YTMxYjYzMzNhNmFkOTdhYWVkZjM0YjE5ZDJhIiwicHJvdmlkZXIiOiJnaXRodWIifSwiaWF0IjoxNzc3NTQ2NzEyLCJleHAiOjE3ODAxMzg3MTJ9.kJcL_j-1Ymh7IOxpk6sLXmZ7ah33vm4ypQfCbL6uLTeVpJrm97_Bv4bAhTJiXmMTnxaDzF2wQf1Zptd55-2hW-KTzxY29fD9EHMXM-T-Wv-6L8GOzaehfsHyGMXoIYISSDWiWtkpPfOlCoCfqRl0zyznwIWdmN2IgYf-drdQP3OLJZEj_DVEVtI-q5N0KGvnH_JjfTQQt89C4oIrYCzc3TZcJHgcJWf8RGSgXmPOYsLd4jtBF_28vqlC3ahzST-bn_RRdGTcA-JMeGXXqLQERbjqyMBeAW9_V5bF2foZ1jS2Rj5foTfYF1p8-w78E7hcoq0MIa5pcVPbfEyIOHuSmw\" target=\"_blank\" rel=\"noopener noreferrer\"><picture><source media=\"(prefers-color-scheme: dark)\" srcset=\"https://cursor.com/assets/images/fix-in-web-dark.png\"><source media=\"(prefers-color-scheme: light)\" srcset=\"https://cursor.com/assets/images/fix-in-web-light.png\"><img alt=\"Fix in Web\" width=\"99\" height=\"28\" src=\"https://cursor.com/assets/images/fix-in-web-dark.png\"></picture></a></div>\n\n\n<sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit 00ff9606838a7a31b6333a6ad97aaedf34b19d2a. Configure [here](https://www.cursor.com/dashboard/bugbot).</sup>\n"},"base_sha":{"kind":"string","value":"514ccec75cccc818254f09e0c284db2c78b2ec2a"},"head_sha":{"kind":"string","value":"ecc2c92ea28c187e76d47f70d6de0024c884c202"},"gold_diff":{"kind":"string","value":"diff --git a/test/src/in_language_tests/test_programs/storage_vec_insert_contract_tests/src/main.sw b/test/src/in_language_tests/test_programs/storage_vec_insert_contract_tests/src/main.sw\nnew file mode 100644\nindex 00000000000..d523111a552\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_vec_insert_contract_tests/src/main.sw\n@@ -0,0 +1,179 @@\n+// TODO: The initial reason for having several `storage_vec` tests is\n+// reaching the limit in the data section size of a single contract\n+// that contained all the tests for `StorageVec<T>` methods.\n+// See: https://github.com/FuelLabs/sway/issues/7612\n+// But even when the issue is solved, it perhaps still makes sense to have\n+// separate test projects for better organization and readability\n+// of the tests.\n+// TODO: Replace `assert(x == y)` back with `assert_eq(x, y)` once `assert_eq` no longer\n+// causes data-section explosion. See also: https://github.com/FuelLabs/sway/issues/7612\n+contract;\n+\n+use test_types::*;\n+\n+use std::hash::{Hash, sha256};\n+use std::storage::storage_vec::*;\n+\n+/// Default number of vector elements to use in tests.\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+const NUM_OF_ELEMENTS: u64 = 11;\n+\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+#[storage(read, write)]\n+fn assert_insert_impl<T>(\n+ slot_id_preimage: u64,\n+)\n+where\n+ T: Eq + TestInstance + AbiEncode,\n+{\n+ assert_non_zero_sized_type::<T>();\n+\n+ let vec: StorageKey<StorageVec<T>> = StorageKey::new(sha256(slot_id_preimage), 0, sha256(slot_id_preimage + 100));\n+\n+ let expected_values = T::instances(NUM_OF_ELEMENTS);\n+\n+ // Append instances.\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ vec.insert(i, expected_values.get(i).unwrap());\n+ assert(expected_values.get(i) == vec.get(i).unwrap().try_read());\n+ assert(i + 1 == vec.len());\n+ i += 1;\n+ }\n+\n+ assert(NUM_OF_ELEMENTS == vec.len());\n+\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ assert(expected_values.get(i) == vec.get(i).unwrap().try_read());\n+ i += 1;\n+ }\n+\n+ // Insert front element and verify right shift.\n+ let inserted_front = T::default();\n+ vec.insert(0, inserted_front);\n+ assert(NUM_OF_ELEMENTS + 1 == vec.len());\n+ assert(inserted_front == vec.get(0).unwrap().read());\n+ assert(expected_values.get(0) == vec.get(1).unwrap().try_read());\n+\n+ // Insert middle element and verify right shift around inserted index.\n+ let inserted_middle = expected_values.get(NUM_OF_ELEMENTS / 2).unwrap();\n+ let middle_index = vec.len() / 2;\n+ let old_middle = vec.get(middle_index).unwrap().try_read();\n+ vec.insert(middle_index, inserted_middle);\n+ assert(NUM_OF_ELEMENTS + 2 == vec.len());\n+ assert(inserted_middle == vec.get(middle_index).unwrap().read());\n+ assert(old_middle == vec.get(middle_index + 1).unwrap().try_read());\n+\n+ // Insert last element and verify it is appended correctly.\n+ let inserted_end = expected_values.get(NUM_OF_ELEMENTS - 1).unwrap();\n+ vec.insert(vec.len(), inserted_end);\n+ assert(NUM_OF_ELEMENTS + 3 == vec.len());\n+ assert(inserted_end == vec.last().unwrap().read());\n+\n+ // Verify full expected sequence after all insertions.\n+ let mut expected_after_insertions = Vec::new();\n+ expected_after_insertions.push(inserted_front);\n+\n+ let mut i = 0;\n+ while i < middle_index - 1 {\n+ expected_after_insertions.push(expected_values.get(i).unwrap());\n+ i += 1;\n+ }\n+\n+ expected_after_insertions.push(inserted_middle);\n+\n+ let mut i = middle_index - 1;\n+ while i < NUM_OF_ELEMENTS {\n+ expected_after_insertions.push(expected_values.get(i).unwrap());\n+ i += 1;\n+ }\n+\n+ expected_after_insertions.push(inserted_end);\n+\n+ let mut i = 0;\n+ while i < expected_after_insertions.len() {\n+ assert(expected_after_insertions.get(i) == vec.get(i).unwrap().try_read());\n+ i += 1;\n+ }\n+}\n+\n+impl Contract {\n+ // Note that zero-sized types like, e.g., `()`, `[u64;0]`, or `EmptyStruct`,\n+ // by definition of the storage access semantics, cannot be stored in\n+ // a `StorageVec<T>`. If the `T` is zero-sized it must be an another\n+ // nested storage type, e.g., `StorageVec<StorageMap<u64, b256>>`.\n+ // So, in all the tests below, we don't have zero-sized types.\n+\n+ #[storage(read, write)]\n+ fn assert_insert() {\n+ assert_insert_impl::<bool>(1);\n+ assert_insert_impl::<u8>(2);\n+ assert_insert_impl::<u16>(3);\n+ assert_insert_impl::<u32>(4);\n+ assert_insert_impl::<u64>(5);\n+ assert_insert_impl::<u256>(6);\n+ assert_insert_impl::<b256>(7);\n+ assert_insert_impl::<raw_slice>(8);\n+ assert_insert_impl::<str>(9);\n+ assert_insert_impl::<str[2]>(10);\n+ assert_insert_impl::<str[5]>(11);\n+ assert_insert_impl::<str[6]>(12);\n+ assert_insert_impl::<str[8]>(13);\n+ assert_insert_impl::<str[12]>(14);\n+ assert_insert_impl::<str[13]>(15);\n+ assert_insert_impl::<[u64; 2]>(16);\n+ assert_insert_impl::<ArrayU8Len2>(17);\n+ assert_insert_impl::<ArrayU8Len5>(18);\n+ assert_insert_impl::<ArrayU8Len6>(19);\n+ assert_insert_impl::<ArrayU8Len8>(20);\n+ assert_insert_impl::<ArrayU8Len12>(21);\n+ assert_insert_impl::<ArrayU8Len13>(22);\n+ assert_insert_impl::<ArrayU64Len3>(23);\n+ assert_insert_impl::<ArrayNestedArrayU8Len2Len3>(24);\n+ assert_insert_impl::<ArrayStructBLen2>(25);\n+ assert_insert_impl::<RawPtrNewtype>(26);\n+ assert_insert_impl::<StructA>(27);\n+ assert_insert_impl::<StructB>(28);\n+ assert_insert_impl::<EnumSingleU8>(29);\n+ assert_insert_impl::<EnumSingleU64>(30);\n+ assert_insert_impl::<EnumSingleBool>(31);\n+ assert_insert_impl::<EnumMultiUnits>(32);\n+ assert_insert_impl::<EnumMultiOneByte>(33);\n+ assert_insert_impl::<EnumU8AndU64>(34);\n+ assert_insert_impl::<EnumQuadSlotSize>(35);\n+ assert_insert_impl::<EnumLargerThanQuadSlot>(36);\n+ assert_insert_impl::<(u8, u32)>(37);\n+ }\n+\n+ #[storage(read, write)]\n+ fn assert_insert_index_out_of_bounds() {\n+ let vec: StorageKey<StorageVec<u64>> = StorageKey::new(b256::zero(), 0, b256::zero());\n+ vec.insert(1, 42);\n+ }\n+\n+ #[storage(write)]\n+ fn assert_insert_nested_storage_type() {\n+ let vec: StorageKey<StorageVec<StorageVec<u64>>> = StorageKey::new(b256::zero(), 0, b256::zero());\n+ vec.insert(0, StorageVec {}); // Nested storage types cannot be inserted.\n+ }\n+\n+}\n+\n+#[test]\n+fn insert() {\n+ let caller = abi(StorageVecInsertContractTestsAbi, CONTRACT_ID);\n+ caller.assert_insert();\n+}\n+\n+#[test(should_revert)]\n+fn insert_out_of_bounds() {\n+ let caller = abi(StorageVecInsertContractTestsAbi, CONTRACT_ID);\n+ caller.assert_insert_index_out_of_bounds();\n+}\n+\n+#[test(should_revert)]\n+fn insert_nested_storage_type() {\n+ let caller = abi(StorageVecInsertContractTestsAbi, CONTRACT_ID);\n+ caller.assert_insert_nested_storage_type();\n+}\n"},"changed_files":{"kind":"list like","value":["test/src/in_language_tests/test_programs/storage_vec_insert_contract_tests/src/main.sw"],"string":"[\n \"test/src/in_language_tests/test_programs/storage_vec_insert_contract_tests/src/main.sw\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"### Test verification uses wrong split point for expected sequence\n\n**Low Severity**\n\n<!-- DESCRIPTION START -->\nThe expected sequence construction in `assert_insert_impl` uses `middle_index` (which is an index into the *vector* after front insertion) as a split point into `expected_values`. After the front insert, original elements are shifted right by one, so `vec[6]` holds `ev[5]`. The loop `while i < middle_index` pushes `ev[0]` through `ev[5]`, then `inserted_middle`, then `ev[6]` onward. But the actual vector has `inserted_middle` at position 6 and `ev[5]` at position 7. The test passes only because `inserted_middle = expected_values.get(NUM_OF_ELEMENTS / 2) = ev[5]`, which is identical to the displaced element. The correct split should be `middle_index - 1` elements from `expected_values` before `inserted_middle`.\n<!-- DESCRIPTION END -->\n\n<!-- BUGBOT_BUG_ID: 1cd43340-fda3-4fe5-bb9c-d67146c7ccc3 -->\n\n<!-- LOCATIONS START\ntest/src/in_language_tests/test_programs/storage_vec_insert_contract_tests/src/main.sw#L77-L90\nLOCATIONS END -->\n<div><a href=\"https://cursor.com/open?data=eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsImtpZCI6ImJ1Z2JvdC12MiJ9.eyJ2ZXJzaW9uIjoxLCJ0eXBlIjoiQlVHQk9UX0ZJWF9JTl9DVVJTT1IiLCJkYXRhIjp7InJlZGlzS2V5IjoiYnVnYm90OmQwMDY4ODg5LTNmNTktNDkzZS1hNWM1LThlYTNkOTM2N2VlMyIsImVuY3J5cHRpb25LZXkiOiJBd25BZjc4YS1ycDBuTklhSzBhaTFYQUljaFpHbkhLUGtTU1dDSWg1NDdzIiwiYnJhbmNoIjoiaXJvbmNldi9keW5hbWljLXN0b3JhZ2Utc3RvcmFnZS12ZWMiLCJyZXBvT3duZXIiOiJGdWVsTGFicyIsInJlcG9OYW1lIjoic3dheSJ9LCJpYXQiOjE3Nzc1NDY3MTIsImV4cCI6MTc4MDEzODcxMn0.cspHKtWTETEOXvIWcb-4C9PDYhhDnlG02hblWALfjNw9uOmapdzbKdm4tLfgqGYycZ16bBTPAHh-5S9aUl7r1NPEbxr3AfbwYaizwYH9rvJSZNYn0hpJ9qC4Olr_wZoE2kHcspzcWGfPk34pMEkXV1-SqIiGvpd7fnokjn8FD1HOsrULA9D655z2psr8YQRyZqsxVcxq3uFGMpIiU7dMnYO7cD6YEE5Elk9TyckUXT9qGkkY_KPOP6q7N4hiBh0w12VbJK_IEC4avCGkynYnfpSJQcTyOv4HNoaGYH-mQYp1uAvr9ecMs3PDb0xqXy98-ZBuPbXGqgfDeP5wKbr1Dw\" target=\"_blank\" rel=\"noopener noreferrer\"><picture><source media=\"(prefers-color-scheme: dark)\" srcset=\"https://cursor.com/assets/images/fix-in-cursor-dark.png\"><source media=\"(prefers-color-scheme: light)\" srcset=\"https://cursor.com/assets/images/fix-in-cursor-light.png\"><img alt=\"Fix in Cursor\" width=\"115\" height=\"28\" src=\"https://cursor.com/assets/images/fix-in-cursor-dark.png\"></picture></a> <a href=\"https://cursor.com/agents?data=eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsImtpZCI6ImJ1Z2JvdC12MiJ9.eyJ2ZXJzaW9uIjoxLCJ0eXBlIjoiQlVHQk9UX0ZJWF9JTl9XRUIiLCJkYXRhIjp7InJlZGlzS2V5IjoiYnVnYm90OmQwMDY4ODg5LTNmNTktNDkzZS1hNWM1LThlYTNkOTM2N2VlMyIsImVuY3J5cHRpb25LZXkiOiJBd25BZjc4YS1ycDBuTklhSzBhaTFYQUljaFpHbkhLUGtTU1dDSWg1NDdzIiwiYnJhbmNoIjoiaXJvbmNldi9keW5hbWljLXN0b3JhZ2Utc3RvcmFnZS12ZWMiLCJyZXBvT3duZXIiOiJGdWVsTGFicyIsInJlcG9OYW1lIjoic3dheSIsInByTnVtYmVyIjo3NjE0LCJjb21taXRTaGEiOiIwMGZmOTYwNjgzOGE3YTMxYjYzMzNhNmFkOTdhYWVkZjM0YjE5ZDJhIiwicHJvdmlkZXIiOiJnaXRodWIifSwiaWF0IjoxNzc3NTQ2NzEyLCJleHAiOjE3ODAxMzg3MTJ9.kJcL_j-1Ymh7IOxpk6sLXmZ7ah33vm4ypQfCbL6uLTeVpJrm97_Bv4bAhTJiXmMTnxaDzF2wQf1Zptd55-2hW-KTzxY29fD9EHMXM-T-Wv-6L8GOzaehfsHyGMXoIYISSDWiWtkpPfOlCoCfqRl0zyznwIWdmN2IgYf-drdQP3OLJZEj_DVEVtI-q5N0KGvnH_JjfTQQt89C4oIrYCzc3TZcJHgcJWf8RGSgXmPOYsLd4jtBF_28vqlC3ahzST-bn_RRdGTcA-JMeGXXqLQERbjqyMBeAW9_V5bF2foZ1jS2Rj5foTfYF1p8-w78E7hcoq0MIa5pcVPbfEyIOHuSmw\" target=\"_blank\" rel=\"noopener noreferrer\"><picture><source media=\"(prefers-color-scheme: dark)\" srcset=\"https://cursor.com/assets/images/fix-in-web-dark.png\"><source media=\"(prefers-color-scheme: light)\" srcset=\"https://cursor.com/assets/images/fix-in-web-light.png\"><img alt=\"Fix in Web\" width=\"99\" height=\"28\" src=\"https://cursor.com/assets/images/fix-in-web-dark.png\"></picture></a></div>\n\n\n<sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit 00ff9606838a7a31b6333a6ad97aaedf34b19d2a. Configure [here](https://www.cursor.com/dashboard/bugbot).</sup>\n","path":"test/src/in_language_tests/test_programs/storage_vec_insert_contract_tests/src/main.sw","hunk":"@@ -0,0 +1,172 @@\n+// TODO: The initial reason for having several `storage_vec` tests is\n+// reaching the limit in the data section size of a single contract\n+// that contained all the tests for `StorageVec<T>` methods.\n+// See: https://github.com/FuelLabs/sway/issues/7612\n+// But even when the issue is solved, it perhaps still makes sense to have\n+// separate test projects for better organization and readability\n+// of the tests.\n+// TODO: Replace `assert(x == y)` back with `assert_eq(x, y)` once `assert_eq` no longer\n+// causes data-section explosion. See also: https://github.com/FuelLabs/sway/issues/7612\n+contract;\n+\n+use test_types::*;\n+\n+use std::hash::{Hash, sha256};\n+use std::storage::storage_vec::*;\n+\n+/// Default number of vector elements to use in tests.\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+const NUM_OF_ELEMENTS: u64 = 11;\n+\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+#[storage(read, write)]\n+fn assert_insert_impl<T>(\n+ slot_id_preimage: u64,\n+)\n+where\n+ T: Eq + TestInstance + AbiEncode,\n+{\n+ assert_non_zero_sized_type::<T>();\n+\n+ let vec: StorageKey<StorageVec<T>> = StorageKey::new(sha256(slot_id_preimage), 0, sha256(slot_id_preimage + 100));\n+\n+ let expected_values = T::instances(NUM_OF_ELEMENTS);\n+\n+ // Append instances.\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ vec.insert(i, expected_values.get(i).unwrap());\n+ assert(expected_values.get(i) == vec.get(i).unwrap().try_read());\n+ assert(i + 1 == vec.len());\n+ i += 1;\n+ }\n+\n+ assert(NUM_OF_ELEMENTS == vec.len());\n+\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ assert(expected_values.get(i) == vec.get(i).unwrap().try_read());\n+ i += 1;\n+ }\n+\n+ // Insert front element and verify right shift.\n+ let inserted_front = T::default();\n+ vec.insert(0, inserted_front);\n+ assert(NUM_OF_ELEMENTS + 1 == vec.len());\n+ assert(inserted_front == vec.get(0).unwrap().read());\n+ assert(expected_values.get(0) == vec.get(1).unwrap().try_read());\n+\n+ // Insert middle element and verify right shift around inserted index.\n+ let inserted_middle = expected_values.get(NUM_OF_ELEMENTS / 2).unwrap();\n+ let middle_index = vec.len() / 2;\n+ let old_middle = vec.get(middle_index).unwrap().try_read();\n+ vec.insert(middle_index, inserted_middle);\n+ assert(NUM_OF_ELEMENTS + 2 == vec.len());\n+ assert(inserted_middle == vec.get(middle_index).unwrap().read());\n+ assert(old_middle == vec.get(middle_index + 1).unwrap().try_read());\n+\n+ // Insert last element and verify it is appended correctly.\n+ let inserted_end = expected_values.get(NUM_OF_ELEMENTS - 1).unwrap();\n+ vec.insert(vec.len(), inserted_end);\n+ assert(NUM_OF_ELEMENTS + 3 == vec.len());\n+ assert(inserted_end == vec.last().unwrap().read());\n+\n+ // Verify full expected sequence after all insertions.\n+ let mut expected_after_insertions = Vec::new();\n+ expected_after_insertions.push(inserted_front);\n+\n+ let mut i = 0;\n+ while i < middle_index {\n+ expected_after_insertions.push(expected_values.get(i).unwrap());\n+ i += 1;\n+ }\n+\n+ expected_after_insertions.push(inserted_middle);\n+\n+ let mut i = middle_index;\n+ while i < NUM_OF_ELEMENTS {\n+ expected_after_insertions.push(expected_values.get(i).unwrap());\n+ i += 1;\n+ }","resolving_sha":"ecc2c92ea28c187e76d47f70d6de0024c884c202","resolving_diff":"diff --git a/test/src/in_language_tests/test_programs/storage_vec_insert_contract_tests/src/main.sw b/test/src/in_language_tests/test_programs/storage_vec_insert_contract_tests/src/main.sw\nnew file mode 100644\nindex 00000000000..d523111a552\n--- /dev/null\n+++ b/test/src/in_language_tests/test_programs/storage_vec_insert_contract_tests/src/main.sw\n@@ -0,0 +1,179 @@\n+// TODO: The initial reason for having several `storage_vec` tests is\n+// reaching the limit in the data section size of a single contract\n+// that contained all the tests for `StorageVec<T>` methods.\n+// See: https://github.com/FuelLabs/sway/issues/7612\n+// But even when the issue is solved, it perhaps still makes sense to have\n+// separate test projects for better organization and readability\n+// of the tests.\n+// TODO: Replace `assert(x == y)` back with `assert_eq(x, y)` once `assert_eq` no longer\n+// causes data-section explosion. See also: https://github.com/FuelLabs/sway/issues/7612\n+contract;\n+\n+use test_types::*;\n+\n+use std::hash::{Hash, sha256};\n+use std::storage::storage_vec::*;\n+\n+/// Default number of vector elements to use in tests.\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+const NUM_OF_ELEMENTS: u64 = 11;\n+\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\n+#[storage(read, write)]\n+fn assert_insert_impl<T>(\n+ slot_id_preimage: u64,\n+)\n+where\n+ T: Eq + TestInstance + AbiEncode,\n+{\n+ assert_non_zero_sized_type::<T>();\n+\n+ let vec: StorageKey<StorageVec<T>> = StorageKey::new(sha256(slot_id_preimage), 0, sha256(slot_id_preimage + 100));\n+\n+ let expected_values = T::instances(NUM_OF_ELEMENTS);\n+\n+ // Append instances.\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ vec.insert(i, expected_values.get(i).unwrap());\n+ assert(expected_values.get(i) == vec.get(i).unwrap().try_read());\n+ assert(i + 1 == vec.len());\n+ i += 1;\n+ }\n+\n+ assert(NUM_OF_ELEMENTS == vec.len());\n+\n+ let mut i = 0;\n+ while i < NUM_OF_ELEMENTS {\n+ assert(expected_values.get(i) == vec.get(i).unwrap().try_read());\n+ i += 1;\n+ }\n+\n+ // Insert front element and verify right shift.\n+ let inserted_front = T::default();\n+ vec.insert(0, inserted_front);\n+ assert(NUM_OF_ELEMENTS + 1 == vec.len());\n+ assert(inserted_front == vec.get(0).unwrap().read());\n+ assert(expected_values.get(0) == vec.get(1).unwrap().try_read());\n+\n+ // Insert middle element and verify right shift around inserted index.\n+ let inserted_middle = expected_values.get(NUM_OF_ELEMENTS / 2).unwrap();\n+ let middle_index = vec.len() / 2;\n+ let old_middle = vec.get(middle_index).unwrap().try_read();\n+ vec.insert(middle_index, inserted_middle);\n+ assert(NUM_OF_ELEMENTS + 2 == vec.len());\n+ assert(inserted_middle == vec.get(middle_index).unwrap().read());\n+ assert(old_middle == vec.get(middle_index + 1).unwrap().try_read());\n+\n+ // Insert last element and verify it is appended correctly.\n+ let inserted_end = expected_values.get(NUM_OF_ELEMENTS - 1).unwrap();\n+ vec.insert(vec.len(), inserted_end);\n+ assert(NUM_OF_ELEMENTS + 3 == vec.len());\n+ assert(inserted_end == vec.last().unwrap().read());\n+\n+ // Verify full expected sequence after all insertions.\n+ let mut expected_after_insertions = Vec::new();\n+ expected_after_insertions.push(inserted_front);\n+\n+ let mut i = 0;\n+ while i < middle_index - 1 {\n+ expected_after_insertions.push(expected_values.get(i).unwrap());\n+ i += 1;\n+ }\n+\n+ expected_after_insertions.push(inserted_middle);\n+\n+ let mut i = middle_index - 1;\n+ while i < NUM_OF_ELEMENTS {\n+ expected_after_insertions.push(expected_values.get(i).unwrap());\n+ i += 1;\n+ }\n+\n+ expected_after_insertions.push(inserted_end);\n+\n+ let mut i = 0;\n+ while i < expected_after_insertions.len() {\n+ assert(expected_after_insertions.get(i) == vec.get(i).unwrap().try_read());\n+ i += 1;\n+ }\n+}\n+\n+impl Contract {\n+ // Note that zero-sized types like, e.g., `()`, `[u64;0]`, or `EmptyStruct`,\n+ // by definition of the storage access semantics, cannot be stored in\n+ // a `StorageVec<T>`. If the `T` is zero-sized it must be an another\n+ // nested storage type, e.g., `StorageVec<StorageMap<u64, b256>>`.\n+ // So, in all the tests below, we don't have zero-sized types.\n+\n+ #[storage(read, write)]\n+ fn assert_insert() {\n+ assert_insert_impl::<bool>(1);\n+ assert_insert_impl::<u8>(2);\n+ assert_insert_impl::<u16>(3);\n+ assert_insert_impl::<u32>(4);\n+ assert_insert_impl::<u64>(5);\n+ assert_insert_impl::<u256>(6);\n+ assert_insert_impl::<b256>(7);\n+ assert_insert_impl::<raw_slice>(8);\n+ assert_insert_impl::<str>(9);\n+ assert_insert_impl::<str[2]>(10);\n+ assert_insert_impl::<str[5]>(11);\n+ assert_insert_impl::<str[6]>(12);\n+ assert_insert_impl::<str[8]>(13);\n+ assert_insert_impl::<str[12]>(14);\n+ assert_insert_impl::<str[13]>(15);\n+ assert_insert_impl::<[u64; 2]>(16);\n+ assert_insert_impl::<ArrayU8Len2>(17);\n+ assert_insert_impl::<ArrayU8Len5>(18);\n+ assert_insert_impl::<ArrayU8Len6>(19);\n+ assert_insert_impl::<ArrayU8Len8>(20);\n+ assert_insert_impl::<ArrayU8Len12>(21);\n+ assert_insert_impl::<ArrayU8Len13>(22);\n+ assert_insert_impl::<ArrayU64Len3>(23);\n+ assert_insert_impl::<ArrayNestedArrayU8Len2Len3>(24);\n+ assert_insert_impl::<ArrayStructBLen2>(25);\n+ assert_insert_impl::<RawPtrNewtype>(26);\n+ assert_insert_impl::<StructA>(27);\n+ assert_insert_impl::<StructB>(28);\n+ assert_insert_impl::<EnumSingleU8>(29);\n+ assert_insert_impl::<EnumSingleU64>(30);\n+ assert_insert_impl::<EnumSingleBool>(31);\n+ assert_insert_impl::<EnumMultiUnits>(32);\n+ assert_insert_impl::<EnumMultiOneByte>(33);\n+ assert_insert_impl::<EnumU8AndU64>(34);\n+ assert_insert_impl::<EnumQuadSlotSize>(35);\n+ assert_insert_impl::<EnumLargerThanQuadSlot>(36);\n+ assert_insert_impl::<(u8, u32)>(37);\n+ }\n+\n+ #[storage(read, write)]\n+ fn assert_insert_index_out_of_bounds() {\n+ let vec: StorageKey<StorageVec<u64>> = StorageKey::new(b256::zero(), 0, b256::zero());\n+ vec.insert(1, 42);\n+ }\n+\n+ #[storage(write)]\n+ fn assert_insert_nested_storage_type() {\n+ let vec: StorageKey<StorageVec<StorageVec<u64>>> = StorageKey::new(b256::zero(), 0, b256::zero());\n+ vec.insert(0, StorageVec {}); // Nested storage types cannot be inserted.\n+ }\n+\n+}\n+\n+#[test]\n+fn insert() {\n+ let caller = abi(StorageVecInsertContractTestsAbi, CONTRACT_ID);\n+ caller.assert_insert();\n+}\n+\n+#[test(should_revert)]\n+fn insert_out_of_bounds() {\n+ let caller = abi(StorageVecInsertContractTestsAbi, CONTRACT_ID);\n+ caller.assert_insert_index_out_of_bounds();\n+}\n+\n+#[test(should_revert)]\n+fn insert_nested_storage_type() {\n+ let caller = abi(StorageVecInsertContractTestsAbi, CONTRACT_ID);\n+ caller.assert_insert_nested_storage_type();\n+}\n"}],"string":"[\n {\n \"comment\": \"### Test verification uses wrong split point for expected sequence\\n\\n**Low Severity**\\n\\n<!-- DESCRIPTION START -->\\nThe expected sequence construction in `assert_insert_impl` uses `middle_index` (which is an index into the *vector* after front insertion) as a split point into `expected_values`. After the front insert, original elements are shifted right by one, so `vec[6]` holds `ev[5]`. The loop `while i < middle_index` pushes `ev[0]` through `ev[5]`, then `inserted_middle`, then `ev[6]` onward. But the actual vector has `inserted_middle` at position 6 and `ev[5]` at position 7. The test passes only because `inserted_middle = expected_values.get(NUM_OF_ELEMENTS / 2) = ev[5]`, which is identical to the displaced element. The correct split should be `middle_index - 1` elements from `expected_values` before `inserted_middle`.\\n<!-- DESCRIPTION END -->\\n\\n<!-- BUGBOT_BUG_ID: 1cd43340-fda3-4fe5-bb9c-d67146c7ccc3 -->\\n\\n<!-- LOCATIONS START\\ntest/src/in_language_tests/test_programs/storage_vec_insert_contract_tests/src/main.sw#L77-L90\\nLOCATIONS END -->\\n<div><a href=\\\"https://cursor.com/open?data=eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsImtpZCI6ImJ1Z2JvdC12MiJ9.eyJ2ZXJzaW9uIjoxLCJ0eXBlIjoiQlVHQk9UX0ZJWF9JTl9DVVJTT1IiLCJkYXRhIjp7InJlZGlzS2V5IjoiYnVnYm90OmQwMDY4ODg5LTNmNTktNDkzZS1hNWM1LThlYTNkOTM2N2VlMyIsImVuY3J5cHRpb25LZXkiOiJBd25BZjc4YS1ycDBuTklhSzBhaTFYQUljaFpHbkhLUGtTU1dDSWg1NDdzIiwiYnJhbmNoIjoiaXJvbmNldi9keW5hbWljLXN0b3JhZ2Utc3RvcmFnZS12ZWMiLCJyZXBvT3duZXIiOiJGdWVsTGFicyIsInJlcG9OYW1lIjoic3dheSJ9LCJpYXQiOjE3Nzc1NDY3MTIsImV4cCI6MTc4MDEzODcxMn0.cspHKtWTETEOXvIWcb-4C9PDYhhDnlG02hblWALfjNw9uOmapdzbKdm4tLfgqGYycZ16bBTPAHh-5S9aUl7r1NPEbxr3AfbwYaizwYH9rvJSZNYn0hpJ9qC4Olr_wZoE2kHcspzcWGfPk34pMEkXV1-SqIiGvpd7fnokjn8FD1HOsrULA9D655z2psr8YQRyZqsxVcxq3uFGMpIiU7dMnYO7cD6YEE5Elk9TyckUXT9qGkkY_KPOP6q7N4hiBh0w12VbJK_IEC4avCGkynYnfpSJQcTyOv4HNoaGYH-mQYp1uAvr9ecMs3PDb0xqXy98-ZBuPbXGqgfDeP5wKbr1Dw\\\" target=\\\"_blank\\\" rel=\\\"noopener noreferrer\\\"><picture><source media=\\\"(prefers-color-scheme: dark)\\\" srcset=\\\"https://cursor.com/assets/images/fix-in-cursor-dark.png\\\"><source media=\\\"(prefers-color-scheme: light)\\\" srcset=\\\"https://cursor.com/assets/images/fix-in-cursor-light.png\\\"><img alt=\\\"Fix in Cursor\\\" width=\\\"115\\\" height=\\\"28\\\" src=\\\"https://cursor.com/assets/images/fix-in-cursor-dark.png\\\"></picture></a> <a href=\\\"https://cursor.com/agents?data=eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsImtpZCI6ImJ1Z2JvdC12MiJ9.eyJ2ZXJzaW9uIjoxLCJ0eXBlIjoiQlVHQk9UX0ZJWF9JTl9XRUIiLCJkYXRhIjp7InJlZGlzS2V5IjoiYnVnYm90OmQwMDY4ODg5LTNmNTktNDkzZS1hNWM1LThlYTNkOTM2N2VlMyIsImVuY3J5cHRpb25LZXkiOiJBd25BZjc4YS1ycDBuTklhSzBhaTFYQUljaFpHbkhLUGtTU1dDSWg1NDdzIiwiYnJhbmNoIjoiaXJvbmNldi9keW5hbWljLXN0b3JhZ2Utc3RvcmFnZS12ZWMiLCJyZXBvT3duZXIiOiJGdWVsTGFicyIsInJlcG9OYW1lIjoic3dheSIsInByTnVtYmVyIjo3NjE0LCJjb21taXRTaGEiOiIwMGZmOTYwNjgzOGE3YTMxYjYzMzNhNmFkOTdhYWVkZjM0YjE5ZDJhIiwicHJvdmlkZXIiOiJnaXRodWIifSwiaWF0IjoxNzc3NTQ2NzEyLCJleHAiOjE3ODAxMzg3MTJ9.kJcL_j-1Ymh7IOxpk6sLXmZ7ah33vm4ypQfCbL6uLTeVpJrm97_Bv4bAhTJiXmMTnxaDzF2wQf1Zptd55-2hW-KTzxY29fD9EHMXM-T-Wv-6L8GOzaehfsHyGMXoIYISSDWiWtkpPfOlCoCfqRl0zyznwIWdmN2IgYf-drdQP3OLJZEj_DVEVtI-q5N0KGvnH_JjfTQQt89C4oIrYCzc3TZcJHgcJWf8RGSgXmPOYsLd4jtBF_28vqlC3ahzST-bn_RRdGTcA-JMeGXXqLQERbjqyMBeAW9_V5bF2foZ1jS2Rj5foTfYF1p8-w78E7hcoq0MIa5pcVPbfEyIOHuSmw\\\" target=\\\"_blank\\\" rel=\\\"noopener noreferrer\\\"><picture><source media=\\\"(prefers-color-scheme: dark)\\\" srcset=\\\"https://cursor.com/assets/images/fix-in-web-dark.png\\\"><source media=\\\"(prefers-color-scheme: light)\\\" srcset=\\\"https://cursor.com/assets/images/fix-in-web-light.png\\\"><img alt=\\\"Fix in Web\\\" width=\\\"99\\\" height=\\\"28\\\" src=\\\"https://cursor.com/assets/images/fix-in-web-dark.png\\\"></picture></a></div>\\n\\n\\n<sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit 00ff9606838a7a31b6333a6ad97aaedf34b19d2a. Configure [here](https://www.cursor.com/dashboard/bugbot).</sup>\\n\",\n \"path\": \"test/src/in_language_tests/test_programs/storage_vec_insert_contract_tests/src/main.sw\",\n \"hunk\": \"@@ -0,0 +1,172 @@\\n+// TODO: The initial reason for having several `storage_vec` tests is\\n+// reaching the limit in the data section size of a single contract\\n+// that contained all the tests for `StorageVec<T>` methods.\\n+// See: https://github.com/FuelLabs/sway/issues/7612\\n+// But even when the issue is solved, it perhaps still makes sense to have\\n+// separate test projects for better organization and readability\\n+// of the tests.\\n+// TODO: Replace `assert(x == y)` back with `assert_eq(x, y)` once `assert_eq` no longer\\n+// causes data-section explosion. See also: https://github.com/FuelLabs/sway/issues/7612\\n+contract;\\n+\\n+use test_types::*;\\n+\\n+use std::hash::{Hash, sha256};\\n+use std::storage::storage_vec::*;\\n+\\n+/// Default number of vector elements to use in tests.\\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\\n+const NUM_OF_ELEMENTS: u64 = 11;\\n+\\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\\n+#[storage(read, write)]\\n+fn assert_insert_impl<T>(\\n+ slot_id_preimage: u64,\\n+)\\n+where\\n+ T: Eq + TestInstance + AbiEncode,\\n+{\\n+ assert_non_zero_sized_type::<T>();\\n+\\n+ let vec: StorageKey<StorageVec<T>> = StorageKey::new(sha256(slot_id_preimage), 0, sha256(slot_id_preimage + 100));\\n+\\n+ let expected_values = T::instances(NUM_OF_ELEMENTS);\\n+\\n+ // Append instances.\\n+ let mut i = 0;\\n+ while i < NUM_OF_ELEMENTS {\\n+ vec.insert(i, expected_values.get(i).unwrap());\\n+ assert(expected_values.get(i) == vec.get(i).unwrap().try_read());\\n+ assert(i + 1 == vec.len());\\n+ i += 1;\\n+ }\\n+\\n+ assert(NUM_OF_ELEMENTS == vec.len());\\n+\\n+ let mut i = 0;\\n+ while i < NUM_OF_ELEMENTS {\\n+ assert(expected_values.get(i) == vec.get(i).unwrap().try_read());\\n+ i += 1;\\n+ }\\n+\\n+ // Insert front element and verify right shift.\\n+ let inserted_front = T::default();\\n+ vec.insert(0, inserted_front);\\n+ assert(NUM_OF_ELEMENTS + 1 == vec.len());\\n+ assert(inserted_front == vec.get(0).unwrap().read());\\n+ assert(expected_values.get(0) == vec.get(1).unwrap().try_read());\\n+\\n+ // Insert middle element and verify right shift around inserted index.\\n+ let inserted_middle = expected_values.get(NUM_OF_ELEMENTS / 2).unwrap();\\n+ let middle_index = vec.len() / 2;\\n+ let old_middle = vec.get(middle_index).unwrap().try_read();\\n+ vec.insert(middle_index, inserted_middle);\\n+ assert(NUM_OF_ELEMENTS + 2 == vec.len());\\n+ assert(inserted_middle == vec.get(middle_index).unwrap().read());\\n+ assert(old_middle == vec.get(middle_index + 1).unwrap().try_read());\\n+\\n+ // Insert last element and verify it is appended correctly.\\n+ let inserted_end = expected_values.get(NUM_OF_ELEMENTS - 1).unwrap();\\n+ vec.insert(vec.len(), inserted_end);\\n+ assert(NUM_OF_ELEMENTS + 3 == vec.len());\\n+ assert(inserted_end == vec.last().unwrap().read());\\n+\\n+ // Verify full expected sequence after all insertions.\\n+ let mut expected_after_insertions = Vec::new();\\n+ expected_after_insertions.push(inserted_front);\\n+\\n+ let mut i = 0;\\n+ while i < middle_index {\\n+ expected_after_insertions.push(expected_values.get(i).unwrap());\\n+ i += 1;\\n+ }\\n+\\n+ expected_after_insertions.push(inserted_middle);\\n+\\n+ let mut i = middle_index;\\n+ while i < NUM_OF_ELEMENTS {\\n+ expected_after_insertions.push(expected_values.get(i).unwrap());\\n+ i += 1;\\n+ }\",\n \"resolving_sha\": \"ecc2c92ea28c187e76d47f70d6de0024c884c202\",\n \"resolving_diff\": \"diff --git a/test/src/in_language_tests/test_programs/storage_vec_insert_contract_tests/src/main.sw b/test/src/in_language_tests/test_programs/storage_vec_insert_contract_tests/src/main.sw\\nnew file mode 100644\\nindex 00000000000..d523111a552\\n--- /dev/null\\n+++ b/test/src/in_language_tests/test_programs/storage_vec_insert_contract_tests/src/main.sw\\n@@ -0,0 +1,179 @@\\n+// TODO: The initial reason for having several `storage_vec` tests is\\n+// reaching the limit in the data section size of a single contract\\n+// that contained all the tests for `StorageVec<T>` methods.\\n+// See: https://github.com/FuelLabs/sway/issues/7612\\n+// But even when the issue is solved, it perhaps still makes sense to have\\n+// separate test projects for better organization and readability\\n+// of the tests.\\n+// TODO: Replace `assert(x == y)` back with `assert_eq(x, y)` once `assert_eq` no longer\\n+// causes data-section explosion. See also: https://github.com/FuelLabs/sway/issues/7612\\n+contract;\\n+\\n+use test_types::*;\\n+\\n+use std::hash::{Hash, sha256};\\n+use std::storage::storage_vec::*;\\n+\\n+/// Default number of vector elements to use in tests.\\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\\n+const NUM_OF_ELEMENTS: u64 = 11;\\n+\\n+#[allow(dead_code)] // TODO-DCA: Remove this `allow` once https://github.com/FuelLabs/sway/issues/7462 is fixed.\\n+#[storage(read, write)]\\n+fn assert_insert_impl<T>(\\n+ slot_id_preimage: u64,\\n+)\\n+where\\n+ T: Eq + TestInstance + AbiEncode,\\n+{\\n+ assert_non_zero_sized_type::<T>();\\n+\\n+ let vec: StorageKey<StorageVec<T>> = StorageKey::new(sha256(slot_id_preimage), 0, sha256(slot_id_preimage + 100));\\n+\\n+ let expected_values = T::instances(NUM_OF_ELEMENTS);\\n+\\n+ // Append instances.\\n+ let mut i = 0;\\n+ while i < NUM_OF_ELEMENTS {\\n+ vec.insert(i, expected_values.get(i).unwrap());\\n+ assert(expected_values.get(i) == vec.get(i).unwrap().try_read());\\n+ assert(i + 1 == vec.len());\\n+ i += 1;\\n+ }\\n+\\n+ assert(NUM_OF_ELEMENTS == vec.len());\\n+\\n+ let mut i = 0;\\n+ while i < NUM_OF_ELEMENTS {\\n+ assert(expected_values.get(i) == vec.get(i).unwrap().try_read());\\n+ i += 1;\\n+ }\\n+\\n+ // Insert front element and verify right shift.\\n+ let inserted_front = T::default();\\n+ vec.insert(0, inserted_front);\\n+ assert(NUM_OF_ELEMENTS + 1 == vec.len());\\n+ assert(inserted_front == vec.get(0).unwrap().read());\\n+ assert(expected_values.get(0) == vec.get(1).unwrap().try_read());\\n+\\n+ // Insert middle element and verify right shift around inserted index.\\n+ let inserted_middle = expected_values.get(NUM_OF_ELEMENTS / 2).unwrap();\\n+ let middle_index = vec.len() / 2;\\n+ let old_middle = vec.get(middle_index).unwrap().try_read();\\n+ vec.insert(middle_index, inserted_middle);\\n+ assert(NUM_OF_ELEMENTS + 2 == vec.len());\\n+ assert(inserted_middle == vec.get(middle_index).unwrap().read());\\n+ assert(old_middle == vec.get(middle_index + 1).unwrap().try_read());\\n+\\n+ // Insert last element and verify it is appended correctly.\\n+ let inserted_end = expected_values.get(NUM_OF_ELEMENTS - 1).unwrap();\\n+ vec.insert(vec.len(), inserted_end);\\n+ assert(NUM_OF_ELEMENTS + 3 == vec.len());\\n+ assert(inserted_end == vec.last().unwrap().read());\\n+\\n+ // Verify full expected sequence after all insertions.\\n+ let mut expected_after_insertions = Vec::new();\\n+ expected_after_insertions.push(inserted_front);\\n+\\n+ let mut i = 0;\\n+ while i < middle_index - 1 {\\n+ expected_after_insertions.push(expected_values.get(i).unwrap());\\n+ i += 1;\\n+ }\\n+\\n+ expected_after_insertions.push(inserted_middle);\\n+\\n+ let mut i = middle_index - 1;\\n+ while i < NUM_OF_ELEMENTS {\\n+ expected_after_insertions.push(expected_values.get(i).unwrap());\\n+ i += 1;\\n+ }\\n+\\n+ expected_after_insertions.push(inserted_end);\\n+\\n+ let mut i = 0;\\n+ while i < expected_after_insertions.len() {\\n+ assert(expected_after_insertions.get(i) == vec.get(i).unwrap().try_read());\\n+ i += 1;\\n+ }\\n+}\\n+\\n+impl Contract {\\n+ // Note that zero-sized types like, e.g., `()`, `[u64;0]`, or `EmptyStruct`,\\n+ // by definition of the storage access semantics, cannot be stored in\\n+ // a `StorageVec<T>`. If the `T` is zero-sized it must be an another\\n+ // nested storage type, e.g., `StorageVec<StorageMap<u64, b256>>`.\\n+ // So, in all the tests below, we don't have zero-sized types.\\n+\\n+ #[storage(read, write)]\\n+ fn assert_insert() {\\n+ assert_insert_impl::<bool>(1);\\n+ assert_insert_impl::<u8>(2);\\n+ assert_insert_impl::<u16>(3);\\n+ assert_insert_impl::<u32>(4);\\n+ assert_insert_impl::<u64>(5);\\n+ assert_insert_impl::<u256>(6);\\n+ assert_insert_impl::<b256>(7);\\n+ assert_insert_impl::<raw_slice>(8);\\n+ assert_insert_impl::<str>(9);\\n+ assert_insert_impl::<str[2]>(10);\\n+ assert_insert_impl::<str[5]>(11);\\n+ assert_insert_impl::<str[6]>(12);\\n+ assert_insert_impl::<str[8]>(13);\\n+ assert_insert_impl::<str[12]>(14);\\n+ assert_insert_impl::<str[13]>(15);\\n+ assert_insert_impl::<[u64; 2]>(16);\\n+ assert_insert_impl::<ArrayU8Len2>(17);\\n+ assert_insert_impl::<ArrayU8Len5>(18);\\n+ assert_insert_impl::<ArrayU8Len6>(19);\\n+ assert_insert_impl::<ArrayU8Len8>(20);\\n+ assert_insert_impl::<ArrayU8Len12>(21);\\n+ assert_insert_impl::<ArrayU8Len13>(22);\\n+ assert_insert_impl::<ArrayU64Len3>(23);\\n+ assert_insert_impl::<ArrayNestedArrayU8Len2Len3>(24);\\n+ assert_insert_impl::<ArrayStructBLen2>(25);\\n+ assert_insert_impl::<RawPtrNewtype>(26);\\n+ assert_insert_impl::<StructA>(27);\\n+ assert_insert_impl::<StructB>(28);\\n+ assert_insert_impl::<EnumSingleU8>(29);\\n+ assert_insert_impl::<EnumSingleU64>(30);\\n+ assert_insert_impl::<EnumSingleBool>(31);\\n+ assert_insert_impl::<EnumMultiUnits>(32);\\n+ assert_insert_impl::<EnumMultiOneByte>(33);\\n+ assert_insert_impl::<EnumU8AndU64>(34);\\n+ assert_insert_impl::<EnumQuadSlotSize>(35);\\n+ assert_insert_impl::<EnumLargerThanQuadSlot>(36);\\n+ assert_insert_impl::<(u8, u32)>(37);\\n+ }\\n+\\n+ #[storage(read, write)]\\n+ fn assert_insert_index_out_of_bounds() {\\n+ let vec: StorageKey<StorageVec<u64>> = StorageKey::new(b256::zero(), 0, b256::zero());\\n+ vec.insert(1, 42);\\n+ }\\n+\\n+ #[storage(write)]\\n+ fn assert_insert_nested_storage_type() {\\n+ let vec: StorageKey<StorageVec<StorageVec<u64>>> = StorageKey::new(b256::zero(), 0, b256::zero());\\n+ vec.insert(0, StorageVec {}); // Nested storage types cannot be inserted.\\n+ }\\n+\\n+}\\n+\\n+#[test]\\n+fn insert() {\\n+ let caller = abi(StorageVecInsertContractTestsAbi, CONTRACT_ID);\\n+ caller.assert_insert();\\n+}\\n+\\n+#[test(should_revert)]\\n+fn insert_out_of_bounds() {\\n+ let caller = abi(StorageVecInsertContractTestsAbi, CONTRACT_ID);\\n+ caller.assert_insert_index_out_of_bounds();\\n+}\\n+\\n+#[test(should_revert)]\\n+fn insert_nested_storage_type() {\\n+ let caller = abi(StorageVecInsertContractTestsAbi, CONTRACT_ID);\\n+ caller.assert_insert_nested_storage_type();\\n+}\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":4099,"cells":{"repo":{"kind":"string","value":"FuelLabs/sway"},"pr_number":{"kind":"number","value":7614,"string":"7,614"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"Implement dynamic storage based `StorageVec`"},"pr_body":{"kind":"string","value":"### Test script runs `forc test` on `test_types` library\n\n**Low Severity**\n\n<!-- DESCRIPTION START -->\nThe `find` command with `-mindepth 2 -maxdepth 2` matches `test_programs/test_types/Forc.toml` alongside actual test projects. This causes the script to run `forc test` on the `test_types` utility library, which is a dependency library not intended to be tested directly. This wastes CI time at best and could produce spurious failures if `forc test` doesn't handle non-test libraries gracefully.\n<!-- DESCRIPTION END -->\n\n<!-- BUGBOT_BUG_ID: a311831f-4de3-4e08-85eb-a44b85fa3019 -->\n\n<!-- LOCATIONS START\ntest/src/in_language_tests/run_in_language_tests.sh#L45-L46\nLOCATIONS END -->\n<div><a href=\"https://cursor.com/open?data=eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsImtpZCI6ImJ1Z2JvdC12MiJ9.eyJ2ZXJzaW9uIjoxLCJ0eXBlIjoiQlVHQk9UX0ZJWF9JTl9DVVJTT1IiLCJkYXRhIjp7InJlZGlzS2V5IjoiYnVnYm90OjFlM2U3OTY1LTRiMGQtNGE3OC05ZTBhLWZlMWUzODlhZmUzMiIsImVuY3J5cHRpb25LZXkiOiJ1NXFZM1Q0anUxQnBPZ0pHME9TeTM3TkFNVEJIdVVQTHZ1ekVMS2g3N08wIiwiYnJhbmNoIjoiaXJvbmNldi9keW5hbWljLXN0b3JhZ2Utc3RvcmFnZS12ZWMiLCJyZXBvT3duZXIiOiJGdWVsTGFicyIsInJlcG9OYW1lIjoic3dheSJ9LCJpYXQiOjE3Nzc1ODQ1NzAsImV4cCI6MTc4MDE3NjU3MH0.E8k9atjoT26rCGZdAtIHGshqs6YSWn-rcdCTwcCP6lku_XXR6eP8ckm3EMkOotYLKxUhHAHCawlQ5sUYpQzDSkkT5tzx7qx8TN_42MgKgsHEc1Ww5HUnBsqyS7ATDynxIiVXW57j0ACwrPg6b5ZN4cwmLZIaPIX4a61sqKRlbiAt3r0jrpat2JyJgk9J_4uLR3Sbq6zDrl5TS1zaBu0frDOqE69j5UzsKqAVgwdpknshuyWIC26sXA-M6wiA9LN6c_Ts9fOSod9IF_gSB12AwVa_OkKD-ip2u8Arxs1vTBJzbw05pe1txucMs5qvzFoIPZtuBqn_Bp-aF4BXLqCWMA\" target=\"_blank\" rel=\"noopener noreferrer\"><picture><source media=\"(prefers-color-scheme: dark)\" srcset=\"https://cursor.com/assets/images/fix-in-cursor-dark.png\"><source media=\"(prefers-color-scheme: light)\" srcset=\"https://cursor.com/assets/images/fix-in-cursor-light.png\"><img alt=\"Fix in Cursor\" width=\"115\" height=\"28\" src=\"https://cursor.com/assets/images/fix-in-cursor-dark.png\"></picture></a> <a href=\"https://cursor.com/agents?data=eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsImtpZCI6ImJ1Z2JvdC12MiJ9.eyJ2ZXJzaW9uIjoxLCJ0eXBlIjoiQlVHQk9UX0ZJWF9JTl9XRUIiLCJkYXRhIjp7InJlZGlzS2V5IjoiYnVnYm90OjFlM2U3OTY1LTRiMGQtNGE3OC05ZTBhLWZlMWUzODlhZmUzMiIsImVuY3J5cHRpb25LZXkiOiJ1NXFZM1Q0anUxQnBPZ0pHME9TeTM3TkFNVEJIdVVQTHZ1ekVMS2g3N08wIiwiYnJhbmNoIjoiaXJvbmNldi9keW5hbWljLXN0b3JhZ2Utc3RvcmFnZS12ZWMiLCJyZXBvT3duZXIiOiJGdWVsTGFicyIsInJlcG9OYW1lIjoic3dheSIsInByTnVtYmVyIjo3NjE0LCJjb21taXRTaGEiOiI4YzU5MWYzMmQxYTE1MGI2NjgxZTAxMWIyNTg4YjAzMTEwYTYzY2E1IiwicHJvdmlkZXIiOiJnaXRodWIifSwiaWF0IjoxNzc3NTg0NTcwLCJleHAiOjE3ODAxNzY1NzB9.RSIltthqgS1_S6A3qnxSR5aNVBhYz91DcwFrW9vCHTrkEZWKm9eSzlqym-sUSYLBTR9Sgu254CrenWd7lltBntg-2AK1dd-tsSP-b0aKLlkKgP7VouNTKLJXZGgQm_tNOJDCwwzs-h1rE49JXiZiZ9TB6np0ZvL30XONrvH5IOLLWC775ltDRLeyO6IgH67-tHCLFY6vKL2bfPXNJ-wU-3Je3i-V1tpXoJtCHpguqtwR8f8zsLHECSvUPhDFAIp331BoX9Zi420hU5WAsWH8xsPPjWT9-606J1CRMa19dmHr7Pf9cCjQfhfc0AI7z6GqqVgpITT1b3XHNG1DB8K22A\" target=\"_blank\" rel=\"noopener noreferrer\"><picture><source media=\"(prefers-color-scheme: dark)\" srcset=\"https://cursor.com/assets/images/fix-in-web-dark.png\"><source media=\"(prefers-color-scheme: light)\" srcset=\"https://cursor.com/assets/images/fix-in-web-light.png\"><img alt=\"Fix in Web\" width=\"99\" height=\"28\" src=\"https://cursor.com/assets/images/fix-in-web-dark.png\"></picture></a></div>\n\n\n<sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit 8c591f32d1a150b6681e011b2588b03110a63ca5. Configure [here](https://www.cursor.com/dashboard/bugbot).</sup>\n"},"base_sha":{"kind":"string","value":"514ccec75cccc818254f09e0c284db2c78b2ec2a"},"head_sha":{"kind":"string","value":"ecc2c92ea28c187e76d47f70d6de0024c884c202"},"gold_diff":{"kind":"string","value":"diff --git a/test/src/in_language_tests/run_in_language_tests.sh b/test/src/in_language_tests/run_in_language_tests.sh\nnew file mode 100755\nindex 00000000000..d09239e82e1\n--- /dev/null\n+++ b/test/src/in_language_tests/run_in_language_tests.sh\n@@ -0,0 +1,71 @@\n+#!/usr/bin/env bash\n+\n+# Run `forc test` individually for each project under test_programs/.\n+#\n+# Usage: ./run_in_language_tests.sh [extra `forc test` args, e.g. --release --experimental ...]\n+#\n+# Note: --error-on-warnings arg is always passed to `forc test`.\n+#\n+# The script continues even when individual test projects fail, and exits with\n+# a non-zero code at the end if any project failed.\n+\n+# TODO: This is a workaround for the issue of `forc test` process getting killed\n+# when running tests on a workspace with large number of projects.\n+# Remove this file and switch to using `forc test` on the entire workspace\n+# once https://github.com/FuelLabs/sway/issues/7613 is resolved.\n+\n+SCRIPT_DIR=\"$(cd \"$(dirname \"${BASH_SOURCE[0]}\")\" && pwd)\"\n+TEST_PROGRAMS_DIR=\"$SCRIPT_DIR/test_programs\"\n+\n+# Always use the `forc` binary built in the repository root (3 levels above here:\n+# test/src/in_language_tests/ -> sway/).\n+REPO_ROOT=\"$(cd \"$SCRIPT_DIR/../../..\" && pwd)\"\n+FORC=\"$REPO_ROOT/target/release/forc\"\n+if [[ ! -x \"$FORC\" ]]; then\n+ echo \"Error: \\`forc\\` binary not found at $FORC\" >&2\n+ echo \"Build it with: cargo build --release -p forc\" >&2\n+ exit 1\n+fi\n+\n+# Projects under test_programs/ that are not test projects and should be skipped.\n+EXCLUDED_PROJECTS=(\n+ \"test_types\"\n+)\n+\n+failed=()\n+passed=()\n+\n+while IFS= read -r -d '' forc_toml; do\n+ project_dir=\"$(dirname \"$forc_toml\")\"\n+ project_name=\"$(basename \"$project_dir\")\"\n+\n+ if [[ \" ${EXCLUDED_PROJECTS[*]} \" == *\" ${project_name} \"* ]]; then\n+ continue\n+ fi\n+\n+ echo \"\"\n+ echo \"==> Testing: $project_name\"\n+\n+ if \"$FORC\" test --error-on-warnings \"$@\" --path \"$project_dir\"; then\n+ passed+=(\"$project_name\")\n+ else\n+ echo \"FAILED: $project_name\" >&2\n+ failed+=(\"$project_name\")\n+ fi\n+done < <(find \"$TEST_PROGRAMS_DIR\" -mindepth 2 -maxdepth 2 -name \"Forc.toml\" -print0 | sort -z)\n+\n+echo \"\"\n+echo \"================================================\"\n+echo \"Results: ${#passed[@]} passed, ${#failed[@]} failed\"\n+echo \"================================================\"\n+\n+if [[ ${#failed[@]} -gt 0 ]]; then\n+ echo \"\"\n+ echo \"Failed tests (${#failed[@]}):\"\n+ for f in \"${failed[@]}\"; do\n+ echo \" - $f\"\n+ done\n+ exit 1\n+fi\n+\n+echo \"All ${#passed[@]} tests passed!\"\n"},"changed_files":{"kind":"list like","value":["test/src/in_language_tests/run_in_language_tests.sh"],"string":"[\n \"test/src/in_language_tests/run_in_language_tests.sh\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"### Test script runs `forc test` on `test_types` library\n\n**Low Severity**\n\n<!-- DESCRIPTION START -->\nThe `find` command with `-mindepth 2 -maxdepth 2` matches `test_programs/test_types/Forc.toml` alongside actual test projects. This causes the script to run `forc test` on the `test_types` utility library, which is a dependency library not intended to be tested directly. This wastes CI time at best and could produce spurious failures if `forc test` doesn't handle non-test libraries gracefully.\n<!-- DESCRIPTION END -->\n\n<!-- BUGBOT_BUG_ID: a311831f-4de3-4e08-85eb-a44b85fa3019 -->\n\n<!-- LOCATIONS START\ntest/src/in_language_tests/run_in_language_tests.sh#L45-L46\nLOCATIONS END -->\n<div><a href=\"https://cursor.com/open?data=eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsImtpZCI6ImJ1Z2JvdC12MiJ9.eyJ2ZXJzaW9uIjoxLCJ0eXBlIjoiQlVHQk9UX0ZJWF9JTl9DVVJTT1IiLCJkYXRhIjp7InJlZGlzS2V5IjoiYnVnYm90OjFlM2U3OTY1LTRiMGQtNGE3OC05ZTBhLWZlMWUzODlhZmUzMiIsImVuY3J5cHRpb25LZXkiOiJ1NXFZM1Q0anUxQnBPZ0pHME9TeTM3TkFNVEJIdVVQTHZ1ekVMS2g3N08wIiwiYnJhbmNoIjoiaXJvbmNldi9keW5hbWljLXN0b3JhZ2Utc3RvcmFnZS12ZWMiLCJyZXBvT3duZXIiOiJGdWVsTGFicyIsInJlcG9OYW1lIjoic3dheSJ9LCJpYXQiOjE3Nzc1ODQ1NzAsImV4cCI6MTc4MDE3NjU3MH0.E8k9atjoT26rCGZdAtIHGshqs6YSWn-rcdCTwcCP6lku_XXR6eP8ckm3EMkOotYLKxUhHAHCawlQ5sUYpQzDSkkT5tzx7qx8TN_42MgKgsHEc1Ww5HUnBsqyS7ATDynxIiVXW57j0ACwrPg6b5ZN4cwmLZIaPIX4a61sqKRlbiAt3r0jrpat2JyJgk9J_4uLR3Sbq6zDrl5TS1zaBu0frDOqE69j5UzsKqAVgwdpknshuyWIC26sXA-M6wiA9LN6c_Ts9fOSod9IF_gSB12AwVa_OkKD-ip2u8Arxs1vTBJzbw05pe1txucMs5qvzFoIPZtuBqn_Bp-aF4BXLqCWMA\" target=\"_blank\" rel=\"noopener noreferrer\"><picture><source media=\"(prefers-color-scheme: dark)\" srcset=\"https://cursor.com/assets/images/fix-in-cursor-dark.png\"><source media=\"(prefers-color-scheme: light)\" srcset=\"https://cursor.com/assets/images/fix-in-cursor-light.png\"><img alt=\"Fix in Cursor\" width=\"115\" height=\"28\" src=\"https://cursor.com/assets/images/fix-in-cursor-dark.png\"></picture></a> <a href=\"https://cursor.com/agents?data=eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsImtpZCI6ImJ1Z2JvdC12MiJ9.eyJ2ZXJzaW9uIjoxLCJ0eXBlIjoiQlVHQk9UX0ZJWF9JTl9XRUIiLCJkYXRhIjp7InJlZGlzS2V5IjoiYnVnYm90OjFlM2U3OTY1LTRiMGQtNGE3OC05ZTBhLWZlMWUzODlhZmUzMiIsImVuY3J5cHRpb25LZXkiOiJ1NXFZM1Q0anUxQnBPZ0pHME9TeTM3TkFNVEJIdVVQTHZ1ekVMS2g3N08wIiwiYnJhbmNoIjoiaXJvbmNldi9keW5hbWljLXN0b3JhZ2Utc3RvcmFnZS12ZWMiLCJyZXBvT3duZXIiOiJGdWVsTGFicyIsInJlcG9OYW1lIjoic3dheSIsInByTnVtYmVyIjo3NjE0LCJjb21taXRTaGEiOiI4YzU5MWYzMmQxYTE1MGI2NjgxZTAxMWIyNTg4YjAzMTEwYTYzY2E1IiwicHJvdmlkZXIiOiJnaXRodWIifSwiaWF0IjoxNzc3NTg0NTcwLCJleHAiOjE3ODAxNzY1NzB9.RSIltthqgS1_S6A3qnxSR5aNVBhYz91DcwFrW9vCHTrkEZWKm9eSzlqym-sUSYLBTR9Sgu254CrenWd7lltBntg-2AK1dd-tsSP-b0aKLlkKgP7VouNTKLJXZGgQm_tNOJDCwwzs-h1rE49JXiZiZ9TB6np0ZvL30XONrvH5IOLLWC775ltDRLeyO6IgH67-tHCLFY6vKL2bfPXNJ-wU-3Je3i-V1tpXoJtCHpguqtwR8f8zsLHECSvUPhDFAIp331BoX9Zi420hU5WAsWH8xsPPjWT9-606J1CRMa19dmHr7Pf9cCjQfhfc0AI7z6GqqVgpITT1b3XHNG1DB8K22A\" target=\"_blank\" rel=\"noopener noreferrer\"><picture><source media=\"(prefers-color-scheme: dark)\" srcset=\"https://cursor.com/assets/images/fix-in-web-dark.png\"><source media=\"(prefers-color-scheme: light)\" srcset=\"https://cursor.com/assets/images/fix-in-web-light.png\"><img alt=\"Fix in Web\" width=\"99\" height=\"28\" src=\"https://cursor.com/assets/images/fix-in-web-dark.png\"></picture></a></div>\n\n\n<sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit 8c591f32d1a150b6681e011b2588b03110a63ca5. Configure [here](https://www.cursor.com/dashboard/bugbot).</sup>\n","path":"test/src/in_language_tests/run_in_language_tests.sh","hunk":"@@ -0,0 +1,62 @@\n+#!/usr/bin/env bash\n+\n+# Run `forc test` individually for each project under test_programs/.\n+#\n+# Usage: ./run_in_language_tests.sh [extra `forc test` args, e.g. --release --experimental ...]\n+#\n+# Note: --error-on-warnings arg is always passed to `forc test`.\n+#\n+# The script continues even when individual test projects fail, and exits with\n+# a non-zero code at the end if any project failed.\n+\n+# TODO: This is a workaround for the issue of `forc test` process getting killed\n+# when running tests on a workspace with large number of projects.\n+# Remove this file and switch to using `forc test` on the entire workspace\n+# once https://github.com/FuelLabs/sway/issues/7613 is resolved.\n+\n+SCRIPT_DIR=\"$(cd \"$(dirname \"${BASH_SOURCE[0]}\")\" && pwd)\"\n+TEST_PROGRAMS_DIR=\"$SCRIPT_DIR/test_programs\"\n+\n+# Always use the `forc` binary built in the repository root (3 levels above here:\n+# test/src/in_language_tests/ -> sway/).\n+REPO_ROOT=\"$(cd \"$SCRIPT_DIR/../../..\" && pwd)\"\n+FORC=\"$REPO_ROOT/target/release/forc\"\n+if [[ ! -x \"$FORC\" ]]; then\n+ echo \"Error: \\`forc\\` binary not found at $FORC\" >&2\n+ echo \"Build it with: cargo build --release -p forc\" >&2\n+ exit 1\n+fi\n+\n+failed=()\n+passed=()\n+\n+while IFS= read -r -d '' forc_toml; do\n+ project_dir=\"$(dirname \"$forc_toml\")\"\n+ project_name=\"$(basename \"$project_dir\")\"\n+\n+ echo \"\"\n+ echo \"==> Testing: $project_name\"\n+\n+ if \"$FORC\" test --error-on-warnings \"$@\" --path \"$project_dir\"; then\n+ passed+=(\"$project_name\")\n+ else\n+ echo \"FAILED: $project_name\" >&2\n+ failed+=(\"$project_name\")\n+ fi\n+done < <(find \"$TEST_PROGRAMS_DIR\" -mindepth 2 -maxdepth 2 -name \"Forc.toml\" -print0 | sort -z)","resolving_sha":"ecc2c92ea28c187e76d47f70d6de0024c884c202","resolving_diff":"diff --git a/test/src/in_language_tests/run_in_language_tests.sh b/test/src/in_language_tests/run_in_language_tests.sh\nnew file mode 100755\nindex 00000000000..d09239e82e1\n--- /dev/null\n+++ b/test/src/in_language_tests/run_in_language_tests.sh\n@@ -0,0 +1,71 @@\n+#!/usr/bin/env bash\n+\n+# Run `forc test` individually for each project under test_programs/.\n+#\n+# Usage: ./run_in_language_tests.sh [extra `forc test` args, e.g. --release --experimental ...]\n+#\n+# Note: --error-on-warnings arg is always passed to `forc test`.\n+#\n+# The script continues even when individual test projects fail, and exits with\n+# a non-zero code at the end if any project failed.\n+\n+# TODO: This is a workaround for the issue of `forc test` process getting killed\n+# when running tests on a workspace with large number of projects.\n+# Remove this file and switch to using `forc test` on the entire workspace\n+# once https://github.com/FuelLabs/sway/issues/7613 is resolved.\n+\n+SCRIPT_DIR=\"$(cd \"$(dirname \"${BASH_SOURCE[0]}\")\" && pwd)\"\n+TEST_PROGRAMS_DIR=\"$SCRIPT_DIR/test_programs\"\n+\n+# Always use the `forc` binary built in the repository root (3 levels above here:\n+# test/src/in_language_tests/ -> sway/).\n+REPO_ROOT=\"$(cd \"$SCRIPT_DIR/../../..\" && pwd)\"\n+FORC=\"$REPO_ROOT/target/release/forc\"\n+if [[ ! -x \"$FORC\" ]]; then\n+ echo \"Error: \\`forc\\` binary not found at $FORC\" >&2\n+ echo \"Build it with: cargo build --release -p forc\" >&2\n+ exit 1\n+fi\n+\n+# Projects under test_programs/ that are not test projects and should be skipped.\n+EXCLUDED_PROJECTS=(\n+ \"test_types\"\n+)\n+\n+failed=()\n+passed=()\n+\n+while IFS= read -r -d '' forc_toml; do\n+ project_dir=\"$(dirname \"$forc_toml\")\"\n+ project_name=\"$(basename \"$project_dir\")\"\n+\n+ if [[ \" ${EXCLUDED_PROJECTS[*]} \" == *\" ${project_name} \"* ]]; then\n+ continue\n+ fi\n+\n+ echo \"\"\n+ echo \"==> Testing: $project_name\"\n+\n+ if \"$FORC\" test --error-on-warnings \"$@\" --path \"$project_dir\"; then\n+ passed+=(\"$project_name\")\n+ else\n+ echo \"FAILED: $project_name\" >&2\n+ failed+=(\"$project_name\")\n+ fi\n+done < <(find \"$TEST_PROGRAMS_DIR\" -mindepth 2 -maxdepth 2 -name \"Forc.toml\" -print0 | sort -z)\n+\n+echo \"\"\n+echo \"================================================\"\n+echo \"Results: ${#passed[@]} passed, ${#failed[@]} failed\"\n+echo \"================================================\"\n+\n+if [[ ${#failed[@]} -gt 0 ]]; then\n+ echo \"\"\n+ echo \"Failed tests (${#failed[@]}):\"\n+ for f in \"${failed[@]}\"; do\n+ echo \" - $f\"\n+ done\n+ exit 1\n+fi\n+\n+echo \"All ${#passed[@]} tests passed!\"\n"}],"string":"[\n {\n \"comment\": \"### Test script runs `forc test` on `test_types` library\\n\\n**Low Severity**\\n\\n<!-- DESCRIPTION START -->\\nThe `find` command with `-mindepth 2 -maxdepth 2` matches `test_programs/test_types/Forc.toml` alongside actual test projects. This causes the script to run `forc test` on the `test_types` utility library, which is a dependency library not intended to be tested directly. This wastes CI time at best and could produce spurious failures if `forc test` doesn't handle non-test libraries gracefully.\\n<!-- DESCRIPTION END -->\\n\\n<!-- BUGBOT_BUG_ID: a311831f-4de3-4e08-85eb-a44b85fa3019 -->\\n\\n<!-- LOCATIONS START\\ntest/src/in_language_tests/run_in_language_tests.sh#L45-L46\\nLOCATIONS END -->\\n<div><a href=\\\"https://cursor.com/open?data=eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsImtpZCI6ImJ1Z2JvdC12MiJ9.eyJ2ZXJzaW9uIjoxLCJ0eXBlIjoiQlVHQk9UX0ZJWF9JTl9DVVJTT1IiLCJkYXRhIjp7InJlZGlzS2V5IjoiYnVnYm90OjFlM2U3OTY1LTRiMGQtNGE3OC05ZTBhLWZlMWUzODlhZmUzMiIsImVuY3J5cHRpb25LZXkiOiJ1NXFZM1Q0anUxQnBPZ0pHME9TeTM3TkFNVEJIdVVQTHZ1ekVMS2g3N08wIiwiYnJhbmNoIjoiaXJvbmNldi9keW5hbWljLXN0b3JhZ2Utc3RvcmFnZS12ZWMiLCJyZXBvT3duZXIiOiJGdWVsTGFicyIsInJlcG9OYW1lIjoic3dheSJ9LCJpYXQiOjE3Nzc1ODQ1NzAsImV4cCI6MTc4MDE3NjU3MH0.E8k9atjoT26rCGZdAtIHGshqs6YSWn-rcdCTwcCP6lku_XXR6eP8ckm3EMkOotYLKxUhHAHCawlQ5sUYpQzDSkkT5tzx7qx8TN_42MgKgsHEc1Ww5HUnBsqyS7ATDynxIiVXW57j0ACwrPg6b5ZN4cwmLZIaPIX4a61sqKRlbiAt3r0jrpat2JyJgk9J_4uLR3Sbq6zDrl5TS1zaBu0frDOqE69j5UzsKqAVgwdpknshuyWIC26sXA-M6wiA9LN6c_Ts9fOSod9IF_gSB12AwVa_OkKD-ip2u8Arxs1vTBJzbw05pe1txucMs5qvzFoIPZtuBqn_Bp-aF4BXLqCWMA\\\" target=\\\"_blank\\\" rel=\\\"noopener noreferrer\\\"><picture><source media=\\\"(prefers-color-scheme: dark)\\\" srcset=\\\"https://cursor.com/assets/images/fix-in-cursor-dark.png\\\"><source media=\\\"(prefers-color-scheme: light)\\\" srcset=\\\"https://cursor.com/assets/images/fix-in-cursor-light.png\\\"><img alt=\\\"Fix in Cursor\\\" width=\\\"115\\\" height=\\\"28\\\" src=\\\"https://cursor.com/assets/images/fix-in-cursor-dark.png\\\"></picture></a> <a href=\\\"https://cursor.com/agents?data=eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsImtpZCI6ImJ1Z2JvdC12MiJ9.eyJ2ZXJzaW9uIjoxLCJ0eXBlIjoiQlVHQk9UX0ZJWF9JTl9XRUIiLCJkYXRhIjp7InJlZGlzS2V5IjoiYnVnYm90OjFlM2U3OTY1LTRiMGQtNGE3OC05ZTBhLWZlMWUzODlhZmUzMiIsImVuY3J5cHRpb25LZXkiOiJ1NXFZM1Q0anUxQnBPZ0pHME9TeTM3TkFNVEJIdVVQTHZ1ekVMS2g3N08wIiwiYnJhbmNoIjoiaXJvbmNldi9keW5hbWljLXN0b3JhZ2Utc3RvcmFnZS12ZWMiLCJyZXBvT3duZXIiOiJGdWVsTGFicyIsInJlcG9OYW1lIjoic3dheSIsInByTnVtYmVyIjo3NjE0LCJjb21taXRTaGEiOiI4YzU5MWYzMmQxYTE1MGI2NjgxZTAxMWIyNTg4YjAzMTEwYTYzY2E1IiwicHJvdmlkZXIiOiJnaXRodWIifSwiaWF0IjoxNzc3NTg0NTcwLCJleHAiOjE3ODAxNzY1NzB9.RSIltthqgS1_S6A3qnxSR5aNVBhYz91DcwFrW9vCHTrkEZWKm9eSzlqym-sUSYLBTR9Sgu254CrenWd7lltBntg-2AK1dd-tsSP-b0aKLlkKgP7VouNTKLJXZGgQm_tNOJDCwwzs-h1rE49JXiZiZ9TB6np0ZvL30XONrvH5IOLLWC775ltDRLeyO6IgH67-tHCLFY6vKL2bfPXNJ-wU-3Je3i-V1tpXoJtCHpguqtwR8f8zsLHECSvUPhDFAIp331BoX9Zi420hU5WAsWH8xsPPjWT9-606J1CRMa19dmHr7Pf9cCjQfhfc0AI7z6GqqVgpITT1b3XHNG1DB8K22A\\\" target=\\\"_blank\\\" rel=\\\"noopener noreferrer\\\"><picture><source media=\\\"(prefers-color-scheme: dark)\\\" srcset=\\\"https://cursor.com/assets/images/fix-in-web-dark.png\\\"><source media=\\\"(prefers-color-scheme: light)\\\" srcset=\\\"https://cursor.com/assets/images/fix-in-web-light.png\\\"><img alt=\\\"Fix in Web\\\" width=\\\"99\\\" height=\\\"28\\\" src=\\\"https://cursor.com/assets/images/fix-in-web-dark.png\\\"></picture></a></div>\\n\\n\\n<sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit 8c591f32d1a150b6681e011b2588b03110a63ca5. Configure [here](https://www.cursor.com/dashboard/bugbot).</sup>\\n\",\n \"path\": \"test/src/in_language_tests/run_in_language_tests.sh\",\n \"hunk\": \"@@ -0,0 +1,62 @@\\n+#!/usr/bin/env bash\\n+\\n+# Run `forc test` individually for each project under test_programs/.\\n+#\\n+# Usage: ./run_in_language_tests.sh [extra `forc test` args, e.g. --release --experimental ...]\\n+#\\n+# Note: --error-on-warnings arg is always passed to `forc test`.\\n+#\\n+# The script continues even when individual test projects fail, and exits with\\n+# a non-zero code at the end if any project failed.\\n+\\n+# TODO: This is a workaround for the issue of `forc test` process getting killed\\n+# when running tests on a workspace with large number of projects.\\n+# Remove this file and switch to using `forc test` on the entire workspace\\n+# once https://github.com/FuelLabs/sway/issues/7613 is resolved.\\n+\\n+SCRIPT_DIR=\\\"$(cd \\\"$(dirname \\\"${BASH_SOURCE[0]}\\\")\\\" && pwd)\\\"\\n+TEST_PROGRAMS_DIR=\\\"$SCRIPT_DIR/test_programs\\\"\\n+\\n+# Always use the `forc` binary built in the repository root (3 levels above here:\\n+# test/src/in_language_tests/ -> sway/).\\n+REPO_ROOT=\\\"$(cd \\\"$SCRIPT_DIR/../../..\\\" && pwd)\\\"\\n+FORC=\\\"$REPO_ROOT/target/release/forc\\\"\\n+if [[ ! -x \\\"$FORC\\\" ]]; then\\n+ echo \\\"Error: \\\\`forc\\\\` binary not found at $FORC\\\" >&2\\n+ echo \\\"Build it with: cargo build --release -p forc\\\" >&2\\n+ exit 1\\n+fi\\n+\\n+failed=()\\n+passed=()\\n+\\n+while IFS= read -r -d '' forc_toml; do\\n+ project_dir=\\\"$(dirname \\\"$forc_toml\\\")\\\"\\n+ project_name=\\\"$(basename \\\"$project_dir\\\")\\\"\\n+\\n+ echo \\\"\\\"\\n+ echo \\\"==> Testing: $project_name\\\"\\n+\\n+ if \\\"$FORC\\\" test --error-on-warnings \\\"$@\\\" --path \\\"$project_dir\\\"; then\\n+ passed+=(\\\"$project_name\\\")\\n+ else\\n+ echo \\\"FAILED: $project_name\\\" >&2\\n+ failed+=(\\\"$project_name\\\")\\n+ fi\\n+done < <(find \\\"$TEST_PROGRAMS_DIR\\\" -mindepth 2 -maxdepth 2 -name \\\"Forc.toml\\\" -print0 | sort -z)\",\n \"resolving_sha\": \"ecc2c92ea28c187e76d47f70d6de0024c884c202\",\n \"resolving_diff\": \"diff --git a/test/src/in_language_tests/run_in_language_tests.sh b/test/src/in_language_tests/run_in_language_tests.sh\\nnew file mode 100755\\nindex 00000000000..d09239e82e1\\n--- /dev/null\\n+++ b/test/src/in_language_tests/run_in_language_tests.sh\\n@@ -0,0 +1,71 @@\\n+#!/usr/bin/env bash\\n+\\n+# Run `forc test` individually for each project under test_programs/.\\n+#\\n+# Usage: ./run_in_language_tests.sh [extra `forc test` args, e.g. --release --experimental ...]\\n+#\\n+# Note: --error-on-warnings arg is always passed to `forc test`.\\n+#\\n+# The script continues even when individual test projects fail, and exits with\\n+# a non-zero code at the end if any project failed.\\n+\\n+# TODO: This is a workaround for the issue of `forc test` process getting killed\\n+# when running tests on a workspace with large number of projects.\\n+# Remove this file and switch to using `forc test` on the entire workspace\\n+# once https://github.com/FuelLabs/sway/issues/7613 is resolved.\\n+\\n+SCRIPT_DIR=\\\"$(cd \\\"$(dirname \\\"${BASH_SOURCE[0]}\\\")\\\" && pwd)\\\"\\n+TEST_PROGRAMS_DIR=\\\"$SCRIPT_DIR/test_programs\\\"\\n+\\n+# Always use the `forc` binary built in the repository root (3 levels above here:\\n+# test/src/in_language_tests/ -> sway/).\\n+REPO_ROOT=\\\"$(cd \\\"$SCRIPT_DIR/../../..\\\" && pwd)\\\"\\n+FORC=\\\"$REPO_ROOT/target/release/forc\\\"\\n+if [[ ! -x \\\"$FORC\\\" ]]; then\\n+ echo \\\"Error: \\\\`forc\\\\` binary not found at $FORC\\\" >&2\\n+ echo \\\"Build it with: cargo build --release -p forc\\\" >&2\\n+ exit 1\\n+fi\\n+\\n+# Projects under test_programs/ that are not test projects and should be skipped.\\n+EXCLUDED_PROJECTS=(\\n+ \\\"test_types\\\"\\n+)\\n+\\n+failed=()\\n+passed=()\\n+\\n+while IFS= read -r -d '' forc_toml; do\\n+ project_dir=\\\"$(dirname \\\"$forc_toml\\\")\\\"\\n+ project_name=\\\"$(basename \\\"$project_dir\\\")\\\"\\n+\\n+ if [[ \\\" ${EXCLUDED_PROJECTS[*]} \\\" == *\\\" ${project_name} \\\"* ]]; then\\n+ continue\\n+ fi\\n+\\n+ echo \\\"\\\"\\n+ echo \\\"==> Testing: $project_name\\\"\\n+\\n+ if \\\"$FORC\\\" test --error-on-warnings \\\"$@\\\" --path \\\"$project_dir\\\"; then\\n+ passed+=(\\\"$project_name\\\")\\n+ else\\n+ echo \\\"FAILED: $project_name\\\" >&2\\n+ failed+=(\\\"$project_name\\\")\\n+ fi\\n+done < <(find \\\"$TEST_PROGRAMS_DIR\\\" -mindepth 2 -maxdepth 2 -name \\\"Forc.toml\\\" -print0 | sort -z)\\n+\\n+echo \\\"\\\"\\n+echo \\\"================================================\\\"\\n+echo \\\"Results: ${#passed[@]} passed, ${#failed[@]} failed\\\"\\n+echo \\\"================================================\\\"\\n+\\n+if [[ ${#failed[@]} -gt 0 ]]; then\\n+ echo \\\"\\\"\\n+ echo \\\"Failed tests (${#failed[@]}):\\\"\\n+ for f in \\\"${failed[@]}\\\"; do\\n+ echo \\\" - $f\\\"\\n+ done\\n+ exit 1\\n+fi\\n+\\n+echo \\\"All ${#passed[@]} tests passed!\\\"\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":40,"numItemsPerPage":100,"numTotalItems":87912,"offset":4000,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6Im1sR1pFYktIVHRVSGRhX1RRdEczQ0N1S3k5ME9Qd25DNHY5elRjM3FVYzgifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4MjgwNDg2OSwianRpIjoiZDQ5OWEwNTAtYTM3Ni00NGE4LTgzNGEtZjA5ODhkMWYyODcyIiwic3ViIjoiL2RhdGFzZXRzL1BvdGF0b0hEL2dpdGh1Yi1wci1yZXNvbHZlIiwiZXhwIjoxNzgyODA4NDY5LCJpc3MiOiJodHRwczovL2h1Z2dpbmdmYWNlLmNvIn0.OkY4DAVnm0Mie2HB6dvdq9f3w9Q936Mc5TTF_S03sHsyeD6u9VSBfL6K1BwYV37FB0EmUSU_LpJz5iPLmEeIDA","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":87912,"numBytesParquet":1412740926}]},"discussionsStats":{"closed":0,"open":0,"total":0},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
repo stringlengths 5 53 | pr_number int32 1 321k | task_type stringclasses 2
values | issue_text stringlengths 0 81.2k | pr_title stringlengths 1 319 | pr_body stringlengths 0 105k | base_sha stringlengths 40 40 | head_sha stringlengths 40 40 | gold_diff stringlengths 0 202M | changed_files listlengths 0 100 | review_threads listlengths 0 100 | test_patch stringlengths 0 23.4M | merged bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
FuelLabs/fuels-ts | 3,875 | issue_to_patch | Allow Custom Modifications On Transaction Request When Using `InvocationScope`
During the implementation of [assembleTx](https://github.com/FuelLabs/fuels-ts/pull/3747), we had to roll back the changes introduced in [#3773](https://github.com/FuelLabs/fuels-ts/pull/3773).
The reverted changes allowed users to manuall... | feat: support TX customization at BaseInvocationScope | - Closes #3815
- Closes #3890
# Release notes
In this release, we:
- Added support for on-the-fly modifications to `TransactionRequest` when using `InvocationScope`
- Made `provider.assembleTx()` to consider `reserveGas` when setting TX `gasLimit`
# Summary
The method `fromRequest` can be used to set... | 4cbd72c1373e2cf2eb29288c65b56bf4e35a045e | 28af88a4cdf73a75d35c04e9ac26888b59eb4d79 | diff --git a/.changeset/huge-stars-attend.md b/.changeset/huge-stars-attend.md
new file mode 100644
index 00000000000..d07df14fb0d
--- /dev/null
+++ b/.changeset/huge-stars-attend.md
@@ -0,0 +1,6 @@
+---
+"@fuel-ts/account": patch
+"@fuel-ts/program": patch
+---
+
+feat: support TX customization at BaseInvocationScope
... | [
".changeset/huge-stars-attend.md",
"apps/docs/.vitepress/config.ts",
"apps/docs/src/guide/contracts/call-parameters.md",
"apps/docs/src/guide/contracts/cost-estimation.md",
"apps/docs/src/guide/contracts/custom-contract-calls.md",
"apps/docs/src/guide/contracts/snippets/call-parameters/forward.ts",
"app... | [
{
"comment": "```suggestion\r\nFor instance, imagine a liquidity pool contract where users can deposit a specific asset to receive some form of benefit. To enhance the experience and make it more attractive, one could use a predicate to cover the transaction fees. This way, users only need to provide the asset ... | diff --git a/packages/fuel-gauge/src/assemble-tx.test.ts b/packages/fuel-gauge/src/assemble-tx.test.ts
index 49ca9084b97..6f2597dad38 100644
--- a/packages/fuel-gauge/src/assemble-tx.test.ts
+++ b/packages/fuel-gauge/src/assemble-tx.test.ts
@@ -12,9 +12,13 @@ import {
ErrorCode,
FuelError,
} from 'fuels';
+impor... | true |
FuelLabs/fuels-ts | 3,875 | comment_to_fix | feat: support TX customization at BaseInvocationScope | ```suggestion
For instance, imagine a liquidity pool contract where users can deposit a specific asset to receive some form of benefit. To enhance the experience and make it more attractive, one could use a predicate to cover the transaction fees. This way, users only need to provide the asset they wish to deposit wit... | 4cbd72c1373e2cf2eb29288c65b56bf4e35a045e | 28af88a4cdf73a75d35c04e9ac26888b59eb4d79 | diff --git a/apps/docs/src/guide/contracts/custom-contract-calls.md b/apps/docs/src/guide/contracts/custom-contract-calls.md
new file mode 100644
index 00000000000..97757c869f2
--- /dev/null
+++ b/apps/docs/src/guide/contracts/custom-contract-calls.md
@@ -0,0 +1,29 @@
+# Custom Contract Call
+
+In certain scenarios, yo... | [
"apps/docs/src/guide/contracts/custom-contract-calls.md"
] | [
{
"comment": "```suggestion\r\nFor instance, imagine a liquidity pool contract where users can deposit a specific asset to receive some form of benefit. To enhance the experience and make it more attractive, one could use a predicate to cover the transaction fees. This way, users only need to provide the asset ... | true | ||
FuelLabs/fuels-ts | 3,875 | comment_to_fix | feat: support TX customization at BaseInvocationScope | ```suggestion
It tells the SDK to skip the automatic `assembleTx` step during the `.call()` execution, since we’ve already manually assembled and funded the transaction using `provider.assembleTx()`.
``` | 4cbd72c1373e2cf2eb29288c65b56bf4e35a045e | 28af88a4cdf73a75d35c04e9ac26888b59eb4d79 | diff --git a/apps/docs/src/guide/contracts/custom-contract-calls.md b/apps/docs/src/guide/contracts/custom-contract-calls.md
new file mode 100644
index 00000000000..97757c869f2
--- /dev/null
+++ b/apps/docs/src/guide/contracts/custom-contract-calls.md
@@ -0,0 +1,29 @@
+# Custom Contract Call
+
+In certain scenarios, yo... | [
"apps/docs/src/guide/contracts/custom-contract-calls.md"
] | [
{
"comment": "```suggestion\r\nIt tells the SDK to skip the automatic `assembleTx` step during the `.call()` execution, since we’ve already manually assembled and funded the transaction using `provider.assembleTx()`.\r\n```",
"path": "apps/docs/src/guide/contracts/custom-contract-calls.md",
"hunk": "@@ ... | true | ||
FuelLabs/fuels-ts | 3,875 | comment_to_fix | feat: support TX customization at BaseInvocationScope | ```suggestion
Skipping this step prevents the SDK from overwriting the prepared transaction and ensures the custom logic remains intact, such as using a predicate as the fee payer.
``` | 4cbd72c1373e2cf2eb29288c65b56bf4e35a045e | 28af88a4cdf73a75d35c04e9ac26888b59eb4d79 | diff --git a/apps/docs/src/guide/contracts/custom-contract-calls.md b/apps/docs/src/guide/contracts/custom-contract-calls.md
new file mode 100644
index 00000000000..97757c869f2
--- /dev/null
+++ b/apps/docs/src/guide/contracts/custom-contract-calls.md
@@ -0,0 +1,29 @@
+# Custom Contract Call
+
+In certain scenarios, yo... | [
"apps/docs/src/guide/contracts/custom-contract-calls.md"
] | [
{
"comment": "```suggestion\r\nSkipping this step prevents the SDK from overwriting the prepared transaction and ensures the custom logic remains intact, such as using a predicate as the fee payer.\r\n```",
"path": "apps/docs/src/guide/contracts/custom-contract-calls.md",
"hunk": "@@ -0,0 +1,14 @@\n+# C... | true | ||
FuelLabs/fuels-ts | 3,886 | issue_to_patch | Better error messages for predicate setData
The current encoding error messages were weak on details and should be improved.
> [!NOTE]
> - Incoming from https://github.com/FuelLabs/fuels-ts/discussions/1545
Typegen'd `PredicateData` must be mandatory when predicate has required arguments
Consider the following p... | fix!: enforce `predicateData` when predicate has arguments | - Closes #3771
- Closes #1552
# Release notes
In this release, we:
- Enforced Predicate's `data` property when the Predicate has arguments
# Breaking Changes
Predicates that define arguments must now be instantiated with the data property. It is no longer allowed to omit data when the predicate expects ... | 842e0f392c6f349b051fefa6ffd8684390900cb5 | 4bf3f1fdc55cf6c2056714c286eef02a53025dd6 | diff --git a/.changeset/loud-bags-deny.md b/.changeset/loud-bags-deny.md
new file mode 100644
index 00000000000..d126cfe917f
--- /dev/null
+++ b/.changeset/loud-bags-deny.md
@@ -0,0 +1,5 @@
+---
+"@fuel-ts/account": minor
+---
+
+fix!: enforce `predicateData` when predicate has arguments
diff --git a/apps/create-fuels-... | [
".changeset/loud-bags-deny.md",
"apps/create-fuels-counter-guide/src/components/Predicate.tsx",
"apps/docs/src/guide/predicates/snippets/deploying-predicates.ts",
"packages/account/src/predicate/predicate.ts",
"packages/fuel-gauge/src/blob-deploy.test.ts",
"packages/fuel-gauge/src/predicate/predicate-conf... | [] | diff --git a/packages/fuel-gauge/src/blob-deploy.test.ts b/packages/fuel-gauge/src/blob-deploy.test.ts
index c09330f1f1d..59bb030cc75 100644
--- a/packages/fuel-gauge/src/blob-deploy.test.ts
+++ b/packages/fuel-gauge/src/blob-deploy.test.ts
@@ -18,7 +18,7 @@ import {
describe('deploying blobs', () => {
function dec... | true |
FuelLabs/fuels-ts | 3,887 | issue_to_patch | `waitForPreConfirmation` Does Not Terminate Subscription Immediately
When using `transactionResponse.waitForPreConfirmation`, the TS SDK listens for subscription updates—either via `statusChange` or `submitAndAwait`—until the transaction reaches one of the `preconfirmation` statuses: `PreconfirmationSuccess` or `Preco... | fix: close subscription after `Preconfirmation` status when applicable | - Closes #3888
# Release notes
In this release, we:
- Close subscription after `Preconfirmation` when another status is not awaited by the user
# Checklist
- [x] All **changes** are **covered** by **tests** (or not applicable)
- [x] All **changes** are **documented** (or not applicable)
- [x] I **revie... | 388ad982771a06e73334275c2c96eed8402057d9 | eae817ef4ded37f7122a2a8bf25b5d2d65913916 | diff --git a/.changeset/rare-kids-grab.md b/.changeset/rare-kids-grab.md
new file mode 100644
index 00000000000..c0f63450039
--- /dev/null
+++ b/.changeset/rare-kids-grab.md
@@ -0,0 +1,5 @@
+---
+"@fuel-ts/account": patch
+---
+
+fix: close subscription after `Preconfirmation` status when applicable
diff --git a/packag... | [
".changeset/rare-kids-grab.md",
"packages/account/src/providers/provider.test.ts",
"packages/account/src/providers/transaction-response/transaction-response.ts"
] | [] | diff --git a/packages/account/src/providers/provider.test.ts b/packages/account/src/providers/provider.test.ts
index 48a087ae479..cc56870bfd2 100644
--- a/packages/account/src/providers/provider.test.ts
+++ b/packages/account/src/providers/provider.test.ts
@@ -25,6 +25,7 @@ import { mockIncompatibleVersions } from '../... | true |
FuelLabs/fuels-ts | 3,885 | issue_to_patch | Reintroduction `setData` for the Predicate
# Summary
We previously had a method to `setData` on a predicate; however, this was removed.
We should reintroduce this method to update the predicate data. It should also validate the data that is being passed, and an error should be thrown early. | feat: add `Predicate` method `setData` | - Closes #3818
# Release notes
In this release, we:
- Added method `setData` to `Predicate` class
# Checklist
- [x] All **changes** are **covered** by **tests** (or not applicable)
- [x] All **changes** are **documented** (or not applicable)
- [x] I **reviewed** the **entire PR** myself (preferably, on... | 8889cd7950256ab2d810483c6ea2a0c788490181 | e4747b811731aae2858f5b65bc041b8c9d451244 | diff --git a/.changeset/curvy-coats-laugh.md b/.changeset/curvy-coats-laugh.md
new file mode 100644
index 00000000000..e9d35b2b933
--- /dev/null
+++ b/.changeset/curvy-coats-laugh.md
@@ -0,0 +1,5 @@
+---
+"@fuel-ts/account": patch
+---
+
+feat: add `Predicate` method `setData`
diff --git a/apps/docs/src/guide/predicate... | [
".changeset/curvy-coats-laugh.md",
"apps/docs/src/guide/predicates/methods.md",
"apps/docs/src/guide/predicates/snippets/methods/modified-data.ts",
"apps/docs/src/guide/predicates/snippets/methods/no-modified-data.ts",
"apps/docs/src/guide/predicates/snippets/methods/set-predicate-new-data.ts",
"packages/... | [] | diff --git a/packages/fuel-gauge/src/predicate/predicate-arguments.test.ts b/packages/fuel-gauge/src/predicate/predicate-arguments.test.ts
index 900e991140b..b6b18a25d32 100644
--- a/packages/fuel-gauge/src/predicate/predicate-arguments.test.ts
+++ b/packages/fuel-gauge/src/predicate/predicate-arguments.test.ts
@@ -117... | true |
FuelLabs/fuels-ts | 3,883 | issue_to_patch | chore: fix flaky Vitest tests in browser environment | # Checklist
- [x] All **changes** are **covered** by **tests** (or not applicable)
- [x] All **changes** are **documented** (or not applicable)
- [x] I **reviewed** the **entire PR** myself (preferably, on GH UI)
- [x] I **described** all **Breaking Changes** (or there's none)
| f778fe4298aa1a7d7fc8e80624884d01ca7307ba | 0795d514dd87d3d788fc5dee57690312862af2e6 | diff --git a/.changeset/eighty-lies-end.md b/.changeset/eighty-lies-end.md
new file mode 100644
index 00000000000..03a2355f099
--- /dev/null
+++ b/.changeset/eighty-lies-end.md
@@ -0,0 +1,4 @@
+---
+---
+
+chore: fix flaky Vitest tests in browser environment
diff --git a/packages/fuels/src/setup-launch-node-server.ts b... | [
".changeset/eighty-lies-end.md",
"packages/fuels/src/setup-launch-node-server.ts",
"vitest.browser.config.mts"
] | [] | true | ||
FuelLabs/fuels-ts | 3,882 | issue_to_patch | Remove `demo-react-cra` app
`create-react-app` has been [sunset](https://react.dev/blog/2025/02/14/sunsetting-create-react-app) by the react team so there's no point in us keeping this app alive.
We should also consider removing `demo-nextjs` and `demo-react-vite` because we already have the templates for nextjs and ... | chore: sunsetting `demo-react-cra` | - Closes #3801
# Release notes
In this release, we:
- Sunsetted the `demo-react-app`
# Checklist
- [x] All **changes** are **covered** by **tests** (or not applicable)
- [x] All **changes** are **documented** (or not applicable)
- [x] I **reviewed** the **entire PR** myself (preferably, on GH UI)
- [... | 1b9e399c5503372604a9f08ce975e13b0ebbb110 | 6b39299053e7370fad96123be181e1cfe2023556 | diff --git a/.changeset/config.json b/.changeset/config.json
index ea7d2ddbcae..9bed09ca20c 100644
--- a/.changeset/config.json
+++ b/.changeset/config.json
@@ -11,7 +11,6 @@
"docs",
"demo-fuels",
"demo-bun-fuels",
- "demo-react-cra",
"demo-react-vite",
"demo-nextjs",
"demo-node-esm",
d... | [
".changeset/config.json",
".eslintignore",
".prettierignore",
"apps/demo-react-cra/.gitignore",
"apps/demo-react-cra/CHANGELOG.md",
"apps/demo-react-cra/README.md",
"apps/demo-react-cra/package.json",
"apps/demo-react-cra/public/favicon.ico",
"apps/demo-react-cra/public/index.html",
"apps/demo-rea... | [] | diff --git a/apps/demo-react-cra/src/App.test.tsx b/apps/demo-react-cra/src/App.test.tsx
deleted file mode 100644
index ed5416b7996..00000000000
--- a/apps/demo-react-cra/src/App.test.tsx
+++ /dev/null
@@ -1,9 +0,0 @@
-import React from "react";
-import { render } from "@testing-library/react";
-import App from "./App"... | true |
FuelLabs/fuels-ts | 3,880 | issue_to_patch | ci(release): `v0.100.6` @ `master` | # Summary
In this release, we:
- Made connector `sendTransaction` return `TransactionResponse` instead `TransactionResponseJson`
# Chores
- [#3879](https://github.com/FuelLabs/fuels-ts/pull/3879) - Made connector returns `TransactionResponse` type, by [@Torres-ssf](https://github.com/Torres-ssf) | 303379c7eb329993455b4194ce4c181d16e40ee3 | 5ed2f415171b647718cfb8db10389e3920dc4b32 | diff --git a/.changeset/cyan-oranges-smash.md b/.changeset/cyan-oranges-smash.md
deleted file mode 100644
index 1f40631fe35..00000000000
--- a/.changeset/cyan-oranges-smash.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"@fuel-ts/account": patch
----
-
-chore: made connector returns `TransactionResponse` type
diff --git a/inte... | [
".changeset/cyan-oranges-smash.md",
"internal/check-imports/CHANGELOG.md",
"internal/check-imports/package.json",
"packages/abi-coder/CHANGELOG.md",
"packages/abi-coder/package.json",
"packages/abi-typegen/CHANGELOG.md",
"packages/abi-typegen/package.json",
"packages/account/CHANGELOG.md",
"packages... | [] | true | ||
FuelLabs/fuels-ts | 3,879 | issue_to_patch | chore: made connector returns `TransactionResponse` type | # Release notes
In this release, we:
- Made connector `sendTransaction` return `TransactionResponse` instead `TransactionResponseJson`
# Checklist
- [x] All **changes** are **covered** by **tests** (or not applicable)
- [x] All **changes** are **documented** (or not applicable)
- [x] I **reviewed** the **... | 7f094bbfa577d717977f88e33afae1afca7e17ba | 66ad3c9d9e1743396d30d8f9689c20eb5ab6ec57 | diff --git a/.changeset/cyan-oranges-smash.md b/.changeset/cyan-oranges-smash.md
new file mode 100644
index 00000000000..1f40631fe35
--- /dev/null
+++ b/.changeset/cyan-oranges-smash.md
@@ -0,0 +1,5 @@
+---
+"@fuel-ts/account": patch
+---
+
+chore: made connector returns `TransactionResponse` type
diff --git a/packages... | [
".changeset/cyan-oranges-smash.md",
"packages/account/src/account.ts",
"packages/account/src/connectors/fuel-connector.ts",
"packages/account/src/providers/index.ts",
"packages/account/src/providers/utils/transaction-response-serialization.ts",
"packages/account/test/fixtures/mocked-connector.ts",
"pack... | [] | diff --git a/packages/account/test/fixtures/mocked-connector.ts b/packages/account/test/fixtures/mocked-connector.ts
index 2e4dd63a99d..1d39d527019 100644
--- a/packages/account/test/fixtures/mocked-connector.ts
+++ b/packages/account/test/fixtures/mocked-connector.ts
@@ -11,7 +11,7 @@ import type {
Network,
Sele... | true | |
FuelLabs/fuels-ts | 3,874 | issue_to_patch | ci(release): `v0.100.5` @ `master` | # Summary
In this release, we:
- Implemented helpers to serialize/deserialize `TransactionResponse`
- Fixed error with missing `CALL` receipt in `getAllDecodedLogs`
- Fixed `Provider` auto-refetch strategy
# Features
- [#3878](https://github.com/FuelLabs/fuels-ts/pull/3878) - Implement methods to serialize/deserializ... | 416e9e76d5f36e32b796ec26480a5daf33b9a87a | 8452d3e52144082130dbba2fc2bd93898fa1ec6b | diff --git a/.changeset/bright-steaks-wave.md b/.changeset/bright-steaks-wave.md
deleted file mode 100644
index 6aed675dfc2..00000000000
--- a/.changeset/bright-steaks-wave.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"@fuel-ts/account": patch
----
-
-fix: ensure contract call receipt exists when decoding logs
diff --git a/.... | [
".changeset/bright-steaks-wave.md",
".changeset/khaki-zoos-cough.md",
".changeset/nine-games-arrive.md",
"internal/check-imports/CHANGELOG.md",
"internal/check-imports/package.json",
"packages/abi-coder/CHANGELOG.md",
"packages/abi-coder/package.json",
"packages/abi-typegen/CHANGELOG.md",
"packages/... | [] | true | ||
FuelLabs/fuels-ts | 3,878 | issue_to_patch | Implement method to serialize/deserialize `TransactionResponse`
We must implement two other methods to serialize and deserialize a `TransactionResponse` instance to exchange it between the SDK vs. Connectors/Wallet via JSON RPC. This is necessary for the conclusion of:
- https://github.com/FuelLabs/fuel-connectors/iss... | feat: implement methods to serialize/deserialize `TransactionResponse` | - Closes #3877
# Release notes
In this release, we:
- Implemented helpers to serialize/deserialize `TransactionResponse`
# Checklist
- [x] All **changes** are **covered** by **tests** (or not applicable)
- [x] All **changes** are **documented** (or not applicable)
- [x] I **reviewed** the **entire PR**... | 0a8b276e74f3ba26f5151cbcb562c37633973ada | dca89618a1583e460e4e756c39cdf0c08b93ed81 | diff --git a/.changeset/nine-games-arrive.md b/.changeset/nine-games-arrive.md
new file mode 100644
index 00000000000..1e84841da9e
--- /dev/null
+++ b/.changeset/nine-games-arrive.md
@@ -0,0 +1,5 @@
+---
+"@fuel-ts/account": patch
+---
+
+feat: implement methods to serialize/deserialize `TransactionResponse`
diff --git... | [
".changeset/nine-games-arrive.md",
"packages/account/src/account.ts",
"packages/account/src/connectors/fuel-connector.ts",
"packages/account/src/providers/transaction-request/transaction-request.ts",
"packages/account/src/providers/transaction-response/transaction-response.ts",
"packages/account/src/provi... | [] | diff --git a/packages/account/src/providers/utils/transaction-response-serialization.test.ts b/packages/account/src/providers/utils/transaction-response-serialization.test.ts
new file mode 100644
index 00000000000..f7d792af30b
--- /dev/null
+++ b/packages/account/src/providers/utils/transaction-response-serialization.t... | true |
FuelLabs/fuels-ts | 3,869 | issue_to_patch | Provider re-requesting chain + node config unnecessarily
# Summary
We have logic to re-fetch the chain + node info, given the consensus parameters change (indicating a `fuel-core` update):
https://github.com/FuelLabs/fuels-ts/blob/3af8692471a6bfd865448cdcd51b8536dcbf9a40/packages/account/src/providers/provider.ts#L1... | fix: provider auto-refetch | - Closes #3810
# Release notes
In this release, we:
- Fixed `Provider` auto-refetch strategy
# Checklist
- [x] All **changes** are **covered** by **tests** (or not applicable)
- [x] All **changes** are **documented** (or not applicable)
- [x] I **reviewed** the **entire PR** myself (preferably, on G... | 444b80eaec148961f1317479d0b35f3dbef7fcc8 | caf95048b0d07a5478e35991431aff68943a7c8c | diff --git a/.changeset/khaki-zoos-cough.md b/.changeset/khaki-zoos-cough.md
new file mode 100644
index 00000000000..b3a5dfa4291
--- /dev/null
+++ b/.changeset/khaki-zoos-cough.md
@@ -0,0 +1,5 @@
+---
+"@fuel-ts/account": patch
+---
+
+fix: provider auto-refetch
diff --git a/packages/account/src/providers/operations.gr... | [
".changeset/khaki-zoos-cough.md",
"packages/account/src/providers/operations.graphql",
"packages/account/src/providers/provider.test.ts",
"packages/account/src/providers/provider.ts",
"packages/account/src/providers/utils/serialization.ts",
"packages/account/test/fixtures/chain.ts"
] | [] | diff --git a/packages/account/src/providers/provider.test.ts b/packages/account/src/providers/provider.test.ts
index c7426adb4c9..48a087ae479 100644
--- a/packages/account/src/providers/provider.test.ts
+++ b/packages/account/src/providers/provider.test.ts
@@ -2312,10 +2312,23 @@ describe('Provider', () => {
const... | true |
FuelLabs/sway | 7,653 | issue_to_patch | Improve `storage_benchmarks` tooling | ## Description
This PR reworks how storage benchmark results are collected and compared. Results are no longer accumulated in RESULTS.md; instead, each run saves its output to a timestamped file in the `perf_out` folder, and diffs are computed between any two such files. Benchmarks can also be run as a `just` recipe... | baa7a253690c0ebde40222c8d5ea550ded9dd395 | 1bf4b0b1cb438fa64439bc328084309ca28206c0 | diff --git a/justfile b/justfile
index a19867aec25..6eaf8248f8b 100644
--- a/justfile
+++ b/justfile
@@ -58,10 +58,16 @@ perf-in-lang filter='':
./test/src/in_language_tests/run_in_language_tests.sh --release {{filter}} | tee /dev/stderr | ./scripts/perf/extract-gas-usages.sh > "$outfile"
echo "Gas usages wri... | [
"justfile",
"test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/.gitignore",
"test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/README.md",
"test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/RESULTS.md",
"test/src/e2e_vm_tests/test_programs/should_pass/stora... | [
{
"comment": "### Perf diff output name collision\n\n**Medium Severity**\n\n<!-- DESCRIPTION START -->\n`perf_diff.sh` names its CSV and Markdown outputs using only the ten-digit timestamps parsed from the two input filenames. Any two comparisons that share the same before/after timestamp pair write to the same... | diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/.gitignore b/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/.gitignore
index 13bad1647e4..fd738c1eec6 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/.gitignore
+++ b/test/src/e2e_vm_tests... | true | |
FuelLabs/sway | 7,653 | comment_to_fix | Improve `storage_benchmarks` tooling | ### Perf diff output name collision
**Medium Severity**
<!-- DESCRIPTION START -->
`perf_diff.sh` names its CSV and Markdown outputs using only the ten-digit timestamps parsed from the two input filenames. Any two comparisons that share the same before/after timestamp pair write to the same `perf_out` paths, so a lat... | baa7a253690c0ebde40222c8d5ea550ded9dd395 | 1bf4b0b1cb438fa64439bc328084309ca28206c0 | diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/perf_diff.sh b/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/perf_diff.sh
index 5d74fb9a98c..955c3c13969 100755
--- a/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/perf_diff.sh
+++ b/test/src/e2e_vm... | [
"test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/perf_diff.sh"
] | [
{
"comment": "### Perf diff output name collision\n\n**Medium Severity**\n\n<!-- DESCRIPTION START -->\n`perf_diff.sh` names its CSV and Markdown outputs using only the ten-digit timestamps parsed from the two input filenames. Any two comparisons that share the same before/after timestamp pair write to the same... | true | ||
FuelLabs/sway | 7,653 | comment_to_fix | Improve `storage_benchmarks` tooling | ### perf_out diff files not gitignored
**Low Severity**
<!-- DESCRIPTION START -->
`perf_diff.sh` now writes `.perf-diff.csv` and `.perf-diff.md` under `perf_out/`, and `perf_diff_stats.sh` writes `.perf-diff-stats.md` beside those CSVs. The ignore rules only cover `perf_out/*.txt` and root-level `*.perf-diff.*` patt... | baa7a253690c0ebde40222c8d5ea550ded9dd395 | 1bf4b0b1cb438fa64439bc328084309ca28206c0 | diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/.gitignore b/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/.gitignore
index 13bad1647e4..fd738c1eec6 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/.gitignore
+++ b/test/src/e2e_vm_tests... | [
"test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/.gitignore"
] | [
{
"comment": "### perf_out diff files not gitignored\n\n**Low Severity**\n\n<!-- DESCRIPTION START -->\n`perf_diff.sh` now writes `.perf-diff.csv` and `.perf-diff.md` under `perf_out/`, and `perf_diff_stats.sh` writes `.perf-diff-stats.md` beside those CSVs. The ignore rules only cover `perf_out/*.txt` and root... | true | ||
FuelLabs/sway | 7,654 | issue_to_patch | IR tests snapshots | ## Description
This PR is a necessary change for https://github.com/FuelLabs/sway/pull/7646.
Some IR tests have a bug: their harness is expecting some passes to return `modified = true` even when the pass is not modifying anything. To make sure that #7646 is NOT changing the optimisation itself, but only fixing t... | 65d0272fffd7e4cf201755499e286e09c20028bb | c044fa73051a35d59d72daa22c57c8092e5397bd | diff --git a/Cargo.lock b/Cargo.lock
index 47633dd5ecd..c542d09a12f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -7686,6 +7686,7 @@ dependencies = [
"downcast-rs",
"filecheck",
"indexmap 2.14.0",
+ "insta",
"itertools 0.13.0",
"once_cell",
"peg",
@@ -7697,6 +7698,7 @@ dependencies = [
"sway-ir-macros",
"... | [
"Cargo.lock",
"justfile",
"sway-ir/Cargo.toml",
"sway-ir/tests/ccp/ccp1.ir.snap",
"sway-ir/tests/constants/cbr_cmp_fold.ir.snap",
"sway-ir/tests/constants/u256_cmp.ir.snap",
"sway-ir/tests/constants/u256_ops.ir.snap",
"sway-ir/tests/cse/cse1.ir.snap",
"sway-ir/tests/cse/cse2.ir.snap",
"sway-ir/tes... | [
{
"comment": "### Snapshot failures silently ignored\n\n**High Severity**\n\n<!-- DESCRIPTION START -->\n`insta::assert_snapshot!` runs inside `catch_unwind` and the result is discarded, so a snapshot mismatch no longer fails the test. Regression coverage from the new `.ir.snap` files is effectively optional wh... | diff --git a/sway-ir/tests/ccp/ccp1.ir.snap b/sway-ir/tests/ccp/ccp1.ir.snap
new file mode 100644
index 00000000000..8dff6421cb8
--- /dev/null
+++ b/sway-ir/tests/ccp/ccp1.ir.snap
@@ -0,0 +1,36 @@
+---
+source: sway-ir/tests/tests.rs
+---
+Modified: true
+
+script {
+ fn test1(p: u64) -> u64 {
+ entry(p: u64)... | true | |
FuelLabs/sway | 7,654 | comment_to_fix | IR tests snapshots | ### Snapshot failures silently ignored
**High Severity**
<!-- DESCRIPTION START -->
`insta::assert_snapshot!` runs inside `catch_unwind` and the result is discarded, so a snapshot mismatch no longer fails the test. Regression coverage from the new `.ir.snap` files is effectively optional whenever FileCheck still pass... | 65d0272fffd7e4cf201755499e286e09c20028bb | c044fa73051a35d59d72daa22c57c8092e5397bd | diff --git a/sway-ir/tests/tests.rs b/sway-ir/tests/tests.rs
index 2ede1eb7358..acd491875d8 100644
--- a/sway-ir/tests/tests.rs
+++ b/sway-ir/tests/tests.rs
@@ -1,4 +1,7 @@
-use std::path::PathBuf;
+use std::{
+ panic::catch_unwind,
+ path::{Path, PathBuf},
+};
use itertools::Itertools;
use sway_features::Exp... | [
"sway-ir/tests/tests.rs"
] | [
{
"comment": "### Snapshot failures silently ignored\n\n**High Severity**\n\n<!-- DESCRIPTION START -->\n`insta::assert_snapshot!` runs inside `catch_unwind` and the result is discarded, so a snapshot mismatch no longer fails the test. Regression coverage from the new `.ir.snap` files is effectively optional wh... | true | ||
FuelLabs/sway | 7,652 | issue_to_patch | Fix `forc-fmt` issues with displaced comments
In the `StorageVec` implementation given in #7649 `forc-fmt` displaced some of the comments. The formatting looks weird, but it was left in the PR to satisfy the `forc-fmt-check-sway-lib-std` CI step.
Here is the diff that shows displaced formatting:
```
diff --git a/swa... | Fix swayfmt comment placement after multibyte comments | Fixes #7651.
## Description
This fixes `forc fmt` displacing line comments after earlier inserted comments contain multibyte characters such as `≥`.
The formatter compares parser leaf spans and reinserts comments into formatted code. Those spans are byte offsets, but the comment insertion path returned the inserted ... | e6c1979e32fe73b005afc3bd1ba7f12dd7be4c15 | 64edabd7ff936527518251886a056c0d7a33a497 | diff --git a/sway-lib-std/src/storage/storage_vec.sw b/sway-lib-std/src/storage/storage_vec.sw
index 32cea254387..26c697b3386 100644
--- a/sway-lib-std/src/storage/storage_vec.sw
+++ b/sway-lib-std/src/storage/storage_vec.sw
@@ -1351,7 +1351,9 @@ impl<V> StorageKey<StorageVec<V>> {
// requires the offset t... | [
"sway-lib-std/src/storage/storage_vec.sw",
"swayfmt/src/comments.rs",
"swayfmt/tests/mod.rs"
] | [] | diff --git a/swayfmt/tests/mod.rs b/swayfmt/tests/mod.rs
index c9276e42cc0..fca43138bf5 100644
--- a/swayfmt/tests/mod.rs
+++ b/swayfmt/tests/mod.rs
@@ -62,6 +62,108 @@ fn const_spacing() {
)
}
+#[test]
+fn statement_comments_in_impl_function_body_keep_statement_indentation() {
+ check(
+ indoc! {r#"
... | true |
FuelLabs/sway | 7,649 | issue_to_patch | Implement chunk-based dynamic storage `StorageVec` | ## Description
This PR implements a chunk-based dynamic storage `StorageVec<V>`:
- vec content is stored in consecutive dynamic storage slots each holding at most `CHUNK_MAX_SIZE` bytes of element data.
- all slots hold the same maximum number of elements: `CHUNK_MAX_SIZE / size_of::<V>()`.
- individual elements ... | ac933ff4f16f0e726b099752806b503ad3836627 | 56b5d54eb0a47fbf345081f8ea74739eff875c92 | diff --git a/sway-lib-std/src/storage/storage_vec.sw b/sway-lib-std/src/storage/storage_vec.sw
index 369b7de24dc..32cea254387 100644
--- a/sway-lib-std/src/storage/storage_vec.sw
+++ b/sway-lib-std/src/storage/storage_vec.sw
@@ -65,6 +65,11 @@ pub struct StorageVec<V> {}
/// - `StorageVec<StorageMap<u64, b256>>`
///... | [
"sway-lib-std/src/storage/storage_vec.sw",
"test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/generate_storage_vec_bench.sh",
"test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/storage_fields/src/main.sw",
"test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/st... | [
{
"comment": "### Debug TODO comments left in\n\n**Low Severity**\n\n<!-- DESCRIPTION START -->\nSeveral new `const SIZE_OF_V` lines in `remove`, `insert`, `store_vec`, and `load_vec` carry inline `TODO-IG!: Report this bug.` notes. These read as temporary author debugging markers, not API documentation, and we... | diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/generate_storage_vec_bench.sh b/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/generate_storage_vec_bench.sh
index 4a9d86f00f6..e6365642aec 100755
--- a/test/src/e2e_vm_tests/test_programs/should_pass/storage_benchmarks/... | true | |
FuelLabs/sway | 7,649 | comment_to_fix | Implement chunk-based dynamic storage `StorageVec` | ### Debug TODO comments left in
**Low Severity**
<!-- DESCRIPTION START -->
Several new `const SIZE_OF_V` lines in `remove`, `insert`, `store_vec`, and `load_vec` carry inline `TODO-IG!: Report this bug.` notes. These read as temporary author debugging markers, not API documentation, and were introduced in this chang... | ac933ff4f16f0e726b099752806b503ad3836627 | 56b5d54eb0a47fbf345081f8ea74739eff875c92 | diff --git a/sway-lib-std/src/storage/storage_vec.sw b/sway-lib-std/src/storage/storage_vec.sw
index 369b7de24dc..32cea254387 100644
--- a/sway-lib-std/src/storage/storage_vec.sw
+++ b/sway-lib-std/src/storage/storage_vec.sw
@@ -65,6 +65,11 @@ pub struct StorageVec<V> {}
/// - `StorageVec<StorageMap<u64, b256>>`
///... | [
"sway-lib-std/src/storage/storage_vec.sw"
] | [
{
"comment": "### Debug TODO comments left in\n\n**Low Severity**\n\n<!-- DESCRIPTION START -->\nSeveral new `const SIZE_OF_V` lines in `remove`, `insert`, `store_vec`, and `load_vec` carry inline `TODO-IG!: Report this bug.` notes. These read as temporary author debugging markers, not API documentation, and we... | true | ||
FuelLabs/sway | 7,649 | comment_to_fix | Implement chunk-based dynamic storage `StorageVec` | See my comments. | ac933ff4f16f0e726b099752806b503ad3836627 | 56b5d54eb0a47fbf345081f8ea74739eff875c92 | diff --git a/sway-lib-std/src/storage/storage_vec.sw b/sway-lib-std/src/storage/storage_vec.sw
index 369b7de24dc..32cea254387 100644
--- a/sway-lib-std/src/storage/storage_vec.sw
+++ b/sway-lib-std/src/storage/storage_vec.sw
@@ -65,6 +65,11 @@ pub struct StorageVec<V> {}
/// - `StorageVec<StorageMap<u64, b256>>`
///... | [
"sway-lib-std/src/storage/storage_vec.sw"
] | [
{
"comment": "See my comments.",
"path": "sway-lib-std/src/storage/storage_vec.sw",
"hunk": "@@ -1221,6 +1250,42 @@ impl<V> StorageKey<StorageVec<V>> {\n // /// True if the `StorageVec` stores a storage type, i.e., if `V` is a storage type.\n // const STORES_STORAGE_TYPE: bool = __size_of::<V>()... | true | ||
FuelLabs/sway | 7,649 | comment_to_fix | Implement chunk-based dynamic storage `StorageVec` | Is ' None ' correct here? We should return an instance of the ZST, right? Otherwise, patterns like `while let Some(_) = v.pop()` will not work.
TBH, I am not sure how to create the ZST generically here. | ac933ff4f16f0e726b099752806b503ad3836627 | 56b5d54eb0a47fbf345081f8ea74739eff875c92 | diff --git a/sway-lib-std/src/storage/storage_vec.sw b/sway-lib-std/src/storage/storage_vec.sw
index 369b7de24dc..32cea254387 100644
--- a/sway-lib-std/src/storage/storage_vec.sw
+++ b/sway-lib-std/src/storage/storage_vec.sw
@@ -65,6 +65,11 @@ pub struct StorageVec<V> {}
/// - `StorageVec<StorageMap<u64, b256>>`
///... | [
"sway-lib-std/src/storage/storage_vec.sw"
] | [
{
"comment": "Is ' None ' correct here? We should return an instance of the ZST, right? Otherwise, patterns like `while let Some(_) = v.pop()` will not work.\n\nTBH, I am not sure how to create the ZST generically here.",
"path": "sway-lib-std/src/storage/storage_vec.sw",
"hunk": "@@ -1328,33 +1408,28 @... | true | ||
FuelLabs/sway | 7,649 | comment_to_fix | Implement chunk-based dynamic storage `StorageVec` | ### Nested get wrong StorageKey slot
**High Severity**
<!-- DESCRIPTION START -->
For nested storage element types, `get` builds `StorageKey` with the per-index `sha256` hash as both `slot` and `field_id`, instead of using the vector’s `field_id()` as `slot` and the hash only as `field_id`. Reads and writes through t... | ac933ff4f16f0e726b099752806b503ad3836627 | 56b5d54eb0a47fbf345081f8ea74739eff875c92 | diff --git a/sway-lib-std/src/storage/storage_vec.sw b/sway-lib-std/src/storage/storage_vec.sw
index 369b7de24dc..32cea254387 100644
--- a/sway-lib-std/src/storage/storage_vec.sw
+++ b/sway-lib-std/src/storage/storage_vec.sw
@@ -65,6 +65,11 @@ pub struct StorageVec<V> {}
/// - `StorageVec<StorageMap<u64, b256>>`
///... | [
"sway-lib-std/src/storage/storage_vec.sw"
] | [
{
"comment": "### Nested get wrong StorageKey slot\n\n**High Severity**\n\n<!-- DESCRIPTION START -->\nFor nested storage element types, `get` builds `StorageKey` with the per-index `sha256` hash as both `slot` and `field_id`, instead of using the vector’s `field_id()` as `slot` and the hash only as `field_id`.... | true | ||
FuelLabs/sway | 7,649 | comment_to_fix | Implement chunk-based dynamic storage `StorageVec` | ### Element larger than chunk size
**High Severity**
<!-- DESCRIPTION START -->
When `__size_of::<V>()` exceeds `CHUNK_MAX_SIZE` (1024), `ELEMS_PER_SLOT` becomes zero and `index / ELEMS_PER_SLOT` divides by zero. The layout also requires each element to fit in one chunk, so types larger than the chunk limit are... | ac933ff4f16f0e726b099752806b503ad3836627 | 56b5d54eb0a47fbf345081f8ea74739eff875c92 | diff --git a/sway-lib-std/src/storage/storage_vec.sw b/sway-lib-std/src/storage/storage_vec.sw
index 369b7de24dc..32cea254387 100644
--- a/sway-lib-std/src/storage/storage_vec.sw
+++ b/sway-lib-std/src/storage/storage_vec.sw
@@ -65,6 +65,11 @@ pub struct StorageVec<V> {}
/// - `StorageVec<StorageMap<u64, b256>>`
///... | [
"sway-lib-std/src/storage/storage_vec.sw"
] | [
{
"comment": "### Element larger than chunk size\n\n**High Severity**\n\n<!-- DESCRIPTION START -->\nWhen `__size_of::<V>()` exceeds `CHUNK_MAX_SIZE` (1024), `ELEMS_PER_SLOT` becomes zero and `index / ELEMS_PER_SLOT` divides by zero. The layout also requires each element to fit in one chunk, so types larg... | true | ||
FuelLabs/sway | 7,649 | comment_to_fix | Implement chunk-based dynamic storage `StorageVec` | ### Clear drops extra chunk slots
**Medium Severity**
<!-- DESCRIPTION START -->
After this change, vector elements live in `field_id()`, `field_id()+1`, and further chunk slots. Benchmarks and docs still use `storage.vec.clear()`, which (via `StorageKey` for zero-sized `StorageVec`) only clears a single slot at `fie... | ac933ff4f16f0e726b099752806b503ad3836627 | 56b5d54eb0a47fbf345081f8ea74739eff875c92 | diff --git a/sway-lib-std/src/storage/storage_vec.sw b/sway-lib-std/src/storage/storage_vec.sw
index 369b7de24dc..32cea254387 100644
--- a/sway-lib-std/src/storage/storage_vec.sw
+++ b/sway-lib-std/src/storage/storage_vec.sw
@@ -65,6 +65,11 @@ pub struct StorageVec<V> {}
/// - `StorageVec<StorageMap<u64, b256>>`
///... | [
"sway-lib-std/src/storage/storage_vec.sw"
] | [
{
"comment": "### Clear drops extra chunk slots\n\n**Medium Severity**\n\n<!-- DESCRIPTION START -->\nAfter this change, vector elements live in `field_id()`, `field_id()+1`, and further chunk slots. Benchmarks and docs still use `storage.vec.clear()`, which (via `StorageKey` for zero-sized `StorageVec`) only c... | true | ||
FuelLabs/sway | 7,636 | issue_to_patch | Fix redundant ops | ## Description
We have been considering any `NOOP`, and others, as redundant, but in reality they are only redundant if their const def registers are not read by the immediate op.
This PR takes this into consideration.
## Checklist
- [ ] I have linked to any relevant issues.
- [x] I have commented my code,... | cf225bed222b6bc8849cfa7bcfdb9d2a6ae7aac5 | 7575fe5b2b56f1d8bdc4c5283324d25c90f495da | diff --git a/sway-core/src/asm_generation/fuel/optimizations/constant_propagate.rs b/sway-core/src/asm_generation/fuel/optimizations/constant_propagate.rs
index 90ecbdb9768..41ddfe8191f 100644
--- a/sway-core/src/asm_generation/fuel/optimizations/constant_propagate.rs
+++ b/sway-core/src/asm_generation/fuel/optimizatio... | [
"sway-core/src/asm_generation/fuel/optimizations/constant_propagate.rs",
"sway-core/src/asm_generation/fuel/optimizations/misc.rs",
"sway-core/src/asm_generation/fuel/optimizations/mod.rs",
"sway-core/src/asm_lang/virtual_ops.rs",
"sway-core/src/asm_lang/virtual_register.rs"
] | [
{
"comment": "Nitpick. Nested `if`s with two `else`s looks like a lot of code... \n```suggestion\n let remove = remove && ops.peek().map(|next_op| op.def_const_registers().intersection(&next_op.use_registers()).count()\n == 0).unwrap_or(true);\n```",
"path": "sway-core/src/asm_generation/fuel/opt... | true | ||
FuelLabs/sway | 7,636 | comment_to_fix | Fix redundant ops | Nitpick. Nested `if`s with two `else`s looks like a lot of code...
```suggestion
let remove = remove && ops.peek().map(|next_op| op.def_const_registers().intersection(&next_op.use_registers()).count()
== 0).unwrap_or(true);
``` | cf225bed222b6bc8849cfa7bcfdb9d2a6ae7aac5 | 7575fe5b2b56f1d8bdc4c5283324d25c90f495da | diff --git a/sway-core/src/asm_generation/fuel/optimizations/misc.rs b/sway-core/src/asm_generation/fuel/optimizations/misc.rs
index 9e59fa39a7c..f3229407cbf 100644
--- a/sway-core/src/asm_generation/fuel/optimizations/misc.rs
+++ b/sway-core/src/asm_generation/fuel/optimizations/misc.rs
@@ -81,7 +81,7 @@ impl Abstract... | [
"sway-core/src/asm_generation/fuel/optimizations/misc.rs"
] | [
{
"comment": "Nitpick. Nested `if`s with two `else`s looks like a lot of code... \n```suggestion\n let remove = remove && ops.peek().map(|next_op| op.def_const_registers().intersection(&next_op.use_registers()).count()\n == 0).unwrap_or(true);\n```",
"path": "sway-core/src/asm_generation/fuel/opt... | true | ||
FuelLabs/sway | 7,636 | comment_to_fix | Fix redundant ops | Nitpick.
```suggestion
new_ops.push(op.clone());
``` | cf225bed222b6bc8849cfa7bcfdb9d2a6ae7aac5 | 7575fe5b2b56f1d8bdc4c5283324d25c90f495da | diff --git a/sway-core/src/asm_generation/fuel/optimizations/misc.rs b/sway-core/src/asm_generation/fuel/optimizations/misc.rs
index 9e59fa39a7c..f3229407cbf 100644
--- a/sway-core/src/asm_generation/fuel/optimizations/misc.rs
+++ b/sway-core/src/asm_generation/fuel/optimizations/misc.rs
@@ -81,7 +81,7 @@ impl Abstract... | [
"sway-core/src/asm_generation/fuel/optimizations/misc.rs"
] | [
{
"comment": "Nitpick.\n```suggestion\n new_ops.push(op.clone());\n```",
"path": "sway-core/src/asm_generation/fuel/optimizations/misc.rs",
"hunk": "@@ -92,21 +92,89 @@ impl AbstractInstructionSet {\n self\n }\n \n- pub(crate) fn remove_redundant_ops(mut self) -> AbstractIn... | true | ||
FuelLabs/sway | 7,629 | issue_to_patch | Consider optimizing `mcp dest src $zero` away
At first look, it looks like `mcp dest src $zero` can be safely optimized away (with respect to cleaning the `$err`, of course).
Even if `dest == src` FuelVM will not panic, so except for `$err` reset as in all opcodes, there should be no side-effects.
We should take a c... | Optimize away zero-length MCP/MCPI instructions | ## Description
`MCP` with length=0 does nothing at runtime in FuelVM: no panic, no memory change. It resets `$err` to 0, but every instruction does that anyway. So we can safely strip these out.
This adds two match arms to `remove_redundant_ops()`:
- `MCP(_, _, len)` where `len` is `$zero` (set by constant propagatio... | b556c08b9756a84623c9171ec4c32e72e3970053 | 8d92e1af0a83adeb50949f28568b38ed824b8b05 | diff --git a/sway-core/src/asm_generation/fuel/optimizations/misc.rs b/sway-core/src/asm_generation/fuel/optimizations/misc.rs
index 7fbff419eab..9e59fa39a7c 100644
--- a/sway-core/src/asm_generation/fuel/optimizations/misc.rs
+++ b/sway-core/src/asm_generation/fuel/optimizations/misc.rs
@@ -1,6 +1,8 @@
use super::sup... | [
"sway-core/src/asm_generation/fuel/optimizations/misc.rs",
"test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_encoding_decoding/stdout.snap",
"test/src/ir_generation/tests/mcp_zero_len.sw"
] | [
{
"comment": "To get address semantics for the pointers passed to `asm`, we need to take addresses, otherwise it is interpreted as `mcp` from the absolute address 42 to absolute address 0.\n```suggestion\n asm(dst_ptr: __addr_of(dst), src_ptr: __addr_of(src), zero: 0u64) {\n```",
"path": "test/src/ir_gen... | diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_encoding_decoding/stdout.snap b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_encoding_decoding/stdout.snap
index 70e05c8bb04..032d98ee5c9 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_encoding_decoding/stdout... | true |
FuelLabs/sway | 7,629 | comment_to_fix | Optimize away zero-length MCP/MCPI instructions | To get address semantics for the pointers passed to `asm`, we need to take addresses, otherwise it is interpreted as `mcp` from the absolute address 42 to absolute address 0.
```suggestion
asm(dst_ptr: __addr_of(dst), src_ptr: __addr_of(src), zero: 0u64) {
``` | b556c08b9756a84623c9171ec4c32e72e3970053 | 8d92e1af0a83adeb50949f28568b38ed824b8b05 | diff --git a/test/src/ir_generation/tests/mcp_zero_len.sw b/test/src/ir_generation/tests/mcp_zero_len.sw
new file mode 100644
index 00000000000..288fe3e9a37
--- /dev/null
+++ b/test/src/ir_generation/tests/mcp_zero_len.sw
@@ -0,0 +1,26 @@
+// target-fuelvm
+script;
+
+fn main() -> u64 {
+ let src: u64 = 42;
+ let... | [
"test/src/ir_generation/tests/mcp_zero_len.sw"
] | [
{
"comment": "To get address semantics for the pointers passed to `asm`, we need to take addresses, otherwise it is interpreted as `mcp` from the absolute address 42 to absolute address 0.\n```suggestion\n asm(dst_ptr: __addr_of(dst), src_ptr: __addr_of(src), zero: 0u64) {\n```",
"path": "test/src/ir_gen... | true | ||
FuelLabs/sway | 7,629 | comment_to_fix | Optimize away zero-length MCP/MCPI instructions | Let's also have a test for `mcpi` here. | b556c08b9756a84623c9171ec4c32e72e3970053 | 8d92e1af0a83adeb50949f28568b38ed824b8b05 | diff --git a/test/src/ir_generation/tests/mcp_zero_len.sw b/test/src/ir_generation/tests/mcp_zero_len.sw
new file mode 100644
index 00000000000..288fe3e9a37
--- /dev/null
+++ b/test/src/ir_generation/tests/mcp_zero_len.sw
@@ -0,0 +1,26 @@
+// target-fuelvm
+script;
+
+fn main() -> u64 {
+ let src: u64 = 42;
+ let... | [
"test/src/ir_generation/tests/mcp_zero_len.sw"
] | [
{
"comment": "Let's also have a test for `mcpi` here.",
"path": "test/src/ir_generation/tests/mcp_zero_len.sw",
"hunk": "@@ -0,0 +1,20 @@\n+// target-fuelvm\n+script;\n+\n+fn main() -> u64 {\n+ let src: u64 = 42;\n+ let mut dst: u64 = 0;\n+ asm(dst_ptr: dst, src_ptr: src, zero: 0u64) {\n+ ... | true | ||
FuelLabs/sway | 7,635 | issue_to_patch | Optimize execution speed of `in_language` tests | ## Description
This PR adds optional regex-based filtering to in-language test runs so CI only executes relevant projects for experimental feature-specific variants.
Addresses first part of the #7617.
## Checklist
- [x] I have linked to any relevant issues.
- [x] I have commented my code, particularly in h... | aa2e3b1d2ea6498cc891ea29d004f96790a0991e | 88767d10c466f783b8bdb040334a16dc87290b44 | diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 94c9154ad52..3aa6b53f508 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -545,17 +545,17 @@ jobs:
- name: Run In Language Unit Tests (Release)
run: ./test/src/in_language_tests/run_in_language_tests.sh --relea... | [
".github/workflows/ci.yml",
"test/src/in_language_tests/run_in_language_tests.sh"
] | [] | diff --git a/test/src/in_language_tests/run_in_language_tests.sh b/test/src/in_language_tests/run_in_language_tests.sh
index d09239e82e1..ef503712d5b 100755
--- a/test/src/in_language_tests/run_in_language_tests.sh
+++ b/test/src/in_language_tests/run_in_language_tests.sh
@@ -2,9 +2,12 @@
# Run `forc test` individua... | true | |
FuelLabs/sway | 7,634 | issue_to_patch | Bump to 0.71.2 and fix crates.io publish | ## Summary
- Bump workspace and `sway-lib-std` to **0.71.2** after the failed v0.71.1 crates.io publish (only `sway-utils` 0.71.1 made it up; binaries for v0.71.1 are fine).
- Fix publish breakage from **yanked `core2`** (RUSTSEC-2026-0105): `FuelLabs/publish-crates` runs `cargo update` after each crate, which failed ... | 54a2d0f9426a577c77e6b556317e34020800eb03 | 457ce1d19657e7504060ea9ee985a80fc2b4201e | diff --git a/Cargo.lock b/Cargo.lock
index 112609114f3..47633dd5ecd 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -109,13 +109,13 @@ dependencies = [
"derive_more 2.1.1",
"foldhash",
"hashbrown 0.15.5",
- "indexmap 2.13.1",
+ "indexmap 2.14.0",
"itoa",
"k256",
"keccak-asm",
"paste",
"proptest",
- "rand 0.... | [
"Cargo.lock",
"Cargo.toml",
"forc-pkg/Cargo.toml",
"forc-pkg/src/source/ipfs.rs",
"forc-pkg/src/source/reg/mod.rs",
"sway-lib-std/Forc.toml",
"sway-lsp/tests/utils/Cargo.toml",
"test/src/e2e_vm_tests/test_programs/should_pass/language/attributes/attribute_require/stdout.snap"
] | [
{
"comment": "### Local IPFS API call wrong\n\n**High Severity**\n\n<!-- DESCRIPTION START -->\nLocal package fetch now issues an HTTP GET to `/api/v0/cat`, but Kubo’s RPC API expects POST and the previous client used `/api/v0/get` for `/ipfs/{cid}` paths. Directory CIDs (typical registry sources) need a tar ar... | diff --git a/sway-lsp/tests/utils/Cargo.toml b/sway-lsp/tests/utils/Cargo.toml
index cbb98baae8e..e03a674d3f6 100644
--- a/sway-lsp/tests/utils/Cargo.toml
+++ b/sway-lsp/tests/utils/Cargo.toml
@@ -16,7 +16,7 @@ normal = ["tower"]
assert-json-diff.workspace = true
futures = { workspace = true, features = ["async-await... | true | |
FuelLabs/sway | 7,634 | comment_to_fix | Bump to 0.71.2 and fix crates.io publish | ### Local IPFS API call wrong
**High Severity**
<!-- DESCRIPTION START -->
Local package fetch now issues an HTTP GET to `/api/v0/cat`, but Kubo’s RPC API expects POST and the previous client used `/api/v0/get` for `/ipfs/{cid}` paths. Directory CIDs (typical registry sources) need a tar archive from `get`, not `cat`... | 54a2d0f9426a577c77e6b556317e34020800eb03 | 457ce1d19657e7504060ea9ee985a80fc2b4201e | diff --git a/forc-pkg/src/source/ipfs.rs b/forc-pkg/src/source/ipfs.rs
index 7ac1cf08a7e..4a5a027e3bb 100644
--- a/forc-pkg/src/source/ipfs.rs
+++ b/forc-pkg/src/source/ipfs.rs
@@ -3,12 +3,9 @@ use crate::{
manifest::{self, PackageManifestFile},
source,
};
-use anyhow::Result;
+use anyhow::{Context, Result};... | [
"forc-pkg/src/source/ipfs.rs"
] | [
{
"comment": "### Local IPFS API call wrong\n\n**High Severity**\n\n<!-- DESCRIPTION START -->\nLocal package fetch now issues an HTTP GET to `/api/v0/cat`, but Kubo’s RPC API expects POST and the previous client used `/api/v0/get` for `/ipfs/{cid}` paths. Directory CIDs (typical registry sources) need a tar ar... | true | ||
FuelLabs/sway | 7,634 | comment_to_fix | Bump to 0.71.2 and fix crates.io publish | ### Test leaves HOME unset
**Low Severity**
<!-- DESCRIPTION START -->
`test_fetch_with_local_node_post_cat` sets `HOME` to a temporary directory but never restores the previous value. When the `TempDir` is dropped at the end of the test, `HOME` still points at a removed path, which can make later tests in the same p... | 54a2d0f9426a577c77e6b556317e34020800eb03 | 457ce1d19657e7504060ea9ee985a80fc2b4201e | diff --git a/forc-pkg/src/source/ipfs.rs b/forc-pkg/src/source/ipfs.rs
index 7ac1cf08a7e..4a5a027e3bb 100644
--- a/forc-pkg/src/source/ipfs.rs
+++ b/forc-pkg/src/source/ipfs.rs
@@ -3,12 +3,9 @@ use crate::{
manifest::{self, PackageManifestFile},
source,
};
-use anyhow::Result;
+use anyhow::{Context, Result};... | [
"forc-pkg/src/source/ipfs.rs"
] | [
{
"comment": "### Test leaves HOME unset\n\n**Low Severity**\n\n<!-- DESCRIPTION START -->\n`test_fetch_with_local_node_post_cat` sets `HOME` to a temporary directory but never restores the previous value. When the `TempDir` is dropped at the end of the test, `HOME` still points at a removed path, which can mak... | true | ||
FuelLabs/sway | 7,632 | issue_to_patch | fix help link that needs compiler version | ## Description
Fix required attribute help link.
## Checklist
- [ ] I have linked to any relevant issues.
- [ ] I have commented my code, particularly in hard-to-understand areas.
- [ ] I have updated the documentation where relevant (API docs, the reference, and the Sway book).
- [ ] If my change requir... | f494ba0994ce511398a92b27c4220d299262c364 | 0597b73bd8e9d57bc4e25dc3b2b5d9195722c955 | diff --git a/docs/book/src/advanced/index.md b/docs/book/src/advanced/index.md
index 3d1795af288..207936b3f78 100644
--- a/docs/book/src/advanced/index.md
+++ b/docs/book/src/advanced/index.md
@@ -10,3 +10,4 @@ Advanced concepts.
- [Generics and Trait Constraints](./generics_and_trait_constraints.md)
- [Assembly](./a... | [
"docs/book/src/advanced/index.md",
"sway-error/src/error.rs",
"test/src/e2e_vm_tests/test_programs/should_pass/language/attributes/attribute_require/stdout.snap"
] | [] | diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/attributes/attribute_require/stdout.snap b/test/src/e2e_vm_tests/test_programs/should_pass/language/attributes/attribute_require/stdout.snap
index 9a83e15e125..43e56bdae78 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/attribut... | true | |
FuelLabs/sway | 7,631 | issue_to_patch | Bump to 0.71.1 | b840704fe007503dd7a391a03ec976a599698f37 | e3757f406e53bc2f1fc38a8fd944f062072dd30b | diff --git a/Cargo.lock b/Cargo.lock
index 2fb28ed7759..112609114f3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2505,7 +2505,7 @@ checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
[[package]]
name = "forc"
-version = "0.71.0"
+version = "0.71.1"
dependencies = [
"annotate-snippets",
... | [
"Cargo.lock",
"Cargo.toml",
"sway-lib-std/Forc.toml"
] | [] | true | |||
FuelLabs/sway | 7,575 | issue_to_patch | Compiler attribute to guarantee that types are trivially encodable/decodable
Contract functions can gain a lot of performance if their inputs are trivially decodable, but today there is no easy way for a developer to check if a type is "trivially decodable" or not. And there is not way to fail compilation if a type is... | Attribute for checking of trivial encoding and decoding | ## Description
Closes https://github.com/FuelLabs/sway/issues/7567.
## Checklist
- [ ] I have linked to any relevant issues.
- [ ] I have commented my code, particularly in hard-to-understand areas.
- [ ] I have updated the documentation where relevant (API docs, the reference, and the Sway book).
- [ ... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/docs/book/spell-check-custom-words.txt b/docs/book/spell-check-custom-words.txt
index a45f2308622..eb828999754 100644
--- a/docs/book/spell-check-custom-words.txt
+++ b/docs/book/spell-check-custom-words.txt
@@ -275,3 +275,9 @@ Preload
preloads
Preloads
VM's
+Decodable
+Encodable
+callee
+decodable
+enc... | [
"docs/book/spell-check-custom-words.txt",
"docs/book/src/SUMMARY.md",
"docs/book/src/advanced/trivial_encoding.md",
"sway-ast/src/attribute.rs",
"sway-ast/src/literal.rs",
"sway-core/src/ir_generation.rs",
"sway-core/src/ir_generation/compile.rs",
"sway-core/src/ir_generation/const_eval.rs",
"sway-c... | [
{
"comment": "### Debug statement accidentally committed to production\n\n**Medium Severity**\n\n<!-- DESCRIPTION START -->\nA `dbg!` macro call printing `decls_to_check` was left in the production code path of `compile_to_asm`. This runs on every compilation, printing debug output to stderr for all users of th... | diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/language/intrinsics/intrinsics_args_type_checking/stdout.snap b/test/src/e2e_vm_tests/test_programs/should_fail/language/intrinsics/intrinsics_args_type_checking/stdout.snap
index 56e2029359b..5b71435aae0 100644
--- a/test/src/e2e_vm_tests/test_programs/shoul... | true |
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### Debug statement accidentally committed to production
**Medium Severity**
<!-- DESCRIPTION START -->
A `dbg!` macro call printing `decls_to_check` was left in the production code path of `compile_to_asm`. This runs on every compilation, printing debug output to stderr for all users of the compiler.
<!-- DESCRIPTIO... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/lib.rs b/sway-core/src/lib.rs
index 9a1c701bccc..9cffb101efb 100644
--- a/sway-core/src/lib.rs
+++ b/sway-core/src/lib.rs
@@ -26,11 +26,18 @@ pub mod source_map;
pub mod transform;
pub mod type_system;
+use crate::decl_engine::DeclEngineGet as _;
+use crate::engine_threading::SpannedWithE... | [
"sway-core/src/lib.rs"
] | [
{
"comment": "### Debug statement accidentally committed to production\n\n**Medium Severity**\n\n<!-- DESCRIPTION START -->\nA `dbg!` macro call printing `decls_to_check` was left in the production code path of `compile_to_asm`. This runs on every compilation, printing debug output to stderr for all users of th... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### Misplaced test: non-trivially-decodable struct in should_pass
**High Severity**
<!-- DESCRIPTION START -->
`MyStruct` is annotated with `#[require(trivially_decodable = "true")]` but contains `bool`, `SomeEnum`, and `Vec<u64>` fields — none of which are trivially decodable. The `MemoryRepresentation` comparison i... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/attributes/attribute_require/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/attributes/attribute_require/src/main.sw
new file mode 100644
index 00000000000..5422c5d9aa3
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/s... | [
"test/src/e2e_vm_tests/test_programs/should_pass/language/attributes/attribute_require/src/main.sw"
] | [
{
"comment": "### Misplaced test: non-trivially-decodable struct in should_pass\n\n**High Severity**\n\n<!-- DESCRIPTION START -->\n`MyStruct` is annotated with `#[require(trivially_decodable = \"true\")]` but contains `bool`, `SomeEnum`, and `Vec<u64>` fields — none of which are trivially decodable. The `Memor... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### Attribute value required but silently ignored in check
**Medium Severity**
<!-- DESCRIPTION START -->
The `Require` attribute kind is configured with `args_expect_values => Yes`, meaning a value like `= "true"` or `= "false"` is syntactically required for each argument. However, the actual check in `compile_entry... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/ir_generation/compile.rs b/sway-core/src/ir_generation/compile.rs
index 1a2b95e9ae3..153d420b6c8 100644
--- a/sway-core/src/ir_generation/compile.rs
+++ b/sway-core/src/ir_generation/compile.rs
@@ -1,32 +1,42 @@
+use super::{
+ const_eval::{compile_const_decl, LookupEnv},
+ convert::con... | [
"sway-core/src/ir_generation/compile.rs"
] | [
{
"comment": "### Attribute value required but silently ignored in check\n\n**Medium Severity**\n\n<!-- DESCRIPTION START -->\nThe `Require` attribute kind is configured with `args_expect_values => Yes`, meaning a value like `= \"true\"` or `= \"false\"` is syntactically required for each argument. However, the... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### Require attribute check skipped for predicates and contracts
**High Severity**
<!-- DESCRIPTION START -->
`decls_to_check` is extracted from `TyProgram` and forwarded only to `compile_script`. Both `compile_predicate` and `compile_contract` do not accept a `decls_to_check` parameter, and instead always pass `&[]`... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/ir_generation.rs b/sway-core/src/ir_generation.rs
index 3ea644068e1..aedfd27ce96 100644
--- a/sway-core/src/ir_generation.rs
+++ b/sway-core/src/ir_generation.rs
@@ -11,7 +11,6 @@ use std::{
collections::HashMap,
hash::{DefaultHasher, Hasher},
};
-
use sway_error::error::CompileEr... | [
"sway-core/src/ir_generation.rs"
] | [
{
"comment": "### Require attribute check skipped for predicates and contracts\n\n**High Severity**\n\n<!-- DESCRIPTION START -->\n`decls_to_check` is extracted from `TyProgram` and forwarded only to `compile_script`. Both `compile_predicate` and `compile_contract` do not accept a `decls_to_check` parameter, an... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### Unhandled match arm panics on non-struct decls
**High Severity**
<!-- DESCRIPTION START -->
The `_ => todo!()` catch-all in the `decls_to_check` match will panic at runtime if any non-`StructDecl` variant ends up in the list. The `#[require]` attribute is allowed on enums (`can_annotate_item_kind` returns true fo... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/ir_generation/compile.rs b/sway-core/src/ir_generation/compile.rs
index 1a2b95e9ae3..153d420b6c8 100644
--- a/sway-core/src/ir_generation/compile.rs
+++ b/sway-core/src/ir_generation/compile.rs
@@ -1,32 +1,42 @@
+use super::{
+ const_eval::{compile_const_decl, LookupEnv},
+ convert::con... | [
"sway-core/src/ir_generation/compile.rs"
] | [
{
"comment": "### Unhandled match arm panics on non-struct decls\n\n**High Severity**\n\n<!-- DESCRIPTION START -->\nThe `_ => todo!()` catch-all in the `decls_to_check` match will panic at runtime if any non-`StructDecl` variant ends up in the list. The `#[require]` attribute is allowed on enums (`can_annotate... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### Vec type replacement corrupts nested generic type suggestions
**Low Severity**
<!-- DESCRIPTION START -->
The `replace(">", "; 64]")` call replaces *all* `>` characters in the type name string, not just the closing one from `Vec<...>`. For types like `Vec<SomeStruct<u64>>`, this produces a malformed suggestion li... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/ir_generation/compile.rs b/sway-core/src/ir_generation/compile.rs
index 1a2b95e9ae3..153d420b6c8 100644
--- a/sway-core/src/ir_generation/compile.rs
+++ b/sway-core/src/ir_generation/compile.rs
@@ -1,32 +1,42 @@
+use super::{
+ const_eval::{compile_const_decl, LookupEnv},
+ convert::con... | [
"sway-core/src/ir_generation/compile.rs"
] | [
{
"comment": "### Vec type replacement corrupts nested generic type suggestions\n\n**Low Severity**\n\n<!-- DESCRIPTION START -->\nThe `replace(\">\", \"; 64]\")` call replaces *all* `>` characters in the type name string, not just the closing one from `Vec<...>`. For types like `Vec<SomeStruct<u64>>`, this pro... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### All fields blamed as non-trivial regardless of actual triviality
**Low Severity**
<!-- DESCRIPTION START -->
The diagnostic loop unconditionally pushes an info message for every field from `all_fields_recursive`, stating each field "is not allowing its owner type to be trivially decodable." Fields that are alread... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/ir_generation/compile.rs b/sway-core/src/ir_generation/compile.rs
index 1a2b95e9ae3..153d420b6c8 100644
--- a/sway-core/src/ir_generation/compile.rs
+++ b/sway-core/src/ir_generation/compile.rs
@@ -1,32 +1,42 @@
+use super::{
+ const_eval::{compile_const_decl, LookupEnv},
+ convert::con... | [
"sway-core/src/ir_generation/compile.rs"
] | [
{
"comment": "### All fields blamed as non-trivial regardless of actual triviality\n\n**Low Severity**\n\n<!-- DESCRIPTION START -->\nThe diagnostic loop unconditionally pushes an info message for every field from `all_fields_recursive`, stating each field \"is not allowing its owner type to be trivially decoda... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### Test expects failure but lives in should_pass directory
**Medium Severity**
<!-- DESCRIPTION START -->
The `attribute_require` test is located under `should_pass` but the snapshot expects `exit status: 1` with a compilation error. A test that intentionally triggers a compile error belongs in a `should_fail` direc... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/attributes/attribute_require/stdout.snap b/test/src/e2e_vm_tests/test_programs/should_pass/language/attributes/attribute_require/stdout.snap
new file mode 100644
index 00000000000..9a83e15e125
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/s... | [
"test/src/e2e_vm_tests/test_programs/should_pass/language/attributes/attribute_require/stdout.snap"
] | [
{
"comment": "### Test expects failure but lives in should_pass directory\n\n**Medium Severity**\n\n<!-- DESCRIPTION START -->\nThe `attribute_require` test is located under `should_pass` but the snapshot expects `exit status: 1` with a compilation error. A test that intentionally triggers a compile error belon... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### Trivial check skipped for contracts and predicates
**Medium Severity**
<!-- DESCRIPTION START -->
`decls_to_check` is extracted from the program but only passed through to `compile_entry_function` for scripts. For contracts and predicates, `&[]` is hardcoded, so `#[require]` attribute checks silently do nothing. ... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/ir_generation/compile.rs b/sway-core/src/ir_generation/compile.rs
index 1a2b95e9ae3..153d420b6c8 100644
--- a/sway-core/src/ir_generation/compile.rs
+++ b/sway-core/src/ir_generation/compile.rs
@@ -1,32 +1,42 @@
+use super::{
+ const_eval::{compile_const_decl, LookupEnv},
+ convert::con... | [
"sway-core/src/ir_generation/compile.rs"
] | [
{
"comment": "### Trivial check skipped for contracts and predicates\n\n**Medium Severity**\n\n<!-- DESCRIPTION START -->\n`decls_to_check` is extracted from the program but only passed through to `compile_entry_function` for scripts. For contracts and predicates, `&[]` is hardcoded, so `#[require]` attribute c... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### Overly broad attribute check collects all attributed structs
**Low Severity**
<!-- DESCRIPTION START -->
The check `!d.attributes.is_empty()` adds every struct with *any* attribute (including doc comments, `#[cfg]`, `#[deprecated]`, etc.) to `decls_to_check`. This is overly broad — only structs with `AttributeKin... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/language/ty/declaration/declaration.rs b/sway-core/src/language/ty/declaration/declaration.rs
index f12eeb9fd89..a4888f5c405 100644
--- a/sway-core/src/language/ty/declaration/declaration.rs
+++ b/sway-core/src/language/ty/declaration/declaration.rs
@@ -1,17 +1,17 @@
use crate::{
decl_e... | [
"sway-core/src/language/ty/declaration/declaration.rs"
] | [
{
"comment": "### Overly broad attribute check collects all attributed structs\n\n**Low Severity**\n\n<!-- DESCRIPTION START -->\nThe check `!d.attributes.is_empty()` adds every struct with *any* attribute (including doc comments, `#[cfg]`, `#[deprecated]`, etc.) to `decls_to_check`. This is overly broad — only... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### Bool runtime representation uses range, breaking triviality equality
**Medium Severity**
<!-- DESCRIPTION START -->
The `range` field on `MemoryRepresentation::Blob` is included in the derived `PartialEq`. The runtime representation for `bool` uses `range: Some(0..2)` while the encoding representation uses `range... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/ir_generation/function.rs b/sway-core/src/ir_generation/function.rs
index 2169d4aa07c..79cd8c73610 100644
--- a/sway-core/src/ir_generation/function.rs
+++ b/sway-core/src/ir_generation/function.rs
@@ -28,9 +28,13 @@ use crate::{
types::*,
PanicOccurrence, PanicOccurrences, Panickin... | [
"sway-core/src/ir_generation/function.rs"
] | [
{
"comment": "### Bool runtime representation uses range, breaking triviality equality\n\n**Medium Severity**\n\n<!-- DESCRIPTION START -->\nThe `range` field on `MemoryRepresentation::Blob` is included in the derived `PartialEq`. The runtime representation for `bool` uses `range: Some(0..2)` while the encoding... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### Duplicate test doesn't verify `is_valid` method
**Medium Severity**
<!-- DESCRIPTION START -->
`trivial_bool_when_invalid_is_valid` and `trivial_bool_when_invalid_unwrap` have identical bodies — both call `.unwrap()`. The first test's name implies it verifies that `is_valid()` returns `false` for an invalid value... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-lib-std/src/codec.sw b/sway-lib-std/src/codec.sw
index 32bb8ef5e88..e5527835fb9 100644
--- a/sway-lib-std/src/codec.sw
+++ b/sway-lib-std/src/codec.sw
@@ -3,6 +3,8 @@ library;
use ::ops::*;
use ::raw_ptr::*;
use ::raw_slice::*;
+use ::slice::*;
+use ::error_signals::*;
pub struct Buffer {
b... | [
"sway-lib-std/src/codec.sw"
] | [
{
"comment": "### Duplicate test doesn't verify `is_valid` method\n\n**Medium Severity**\n\n<!-- DESCRIPTION START -->\n`trivial_bool_when_invalid_is_valid` and `trivial_bool_when_invalid_unwrap` have identical bodies — both call `.unwrap()`. The first test's name implies it verifies that `is_valid()` returns `... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### No enum type validation for `EnumDiscriminantCount` intrinsic
**Medium Severity**
<!-- DESCRIPTION START -->
`type_check_enum_discriminant_count` validates argument count and type argument count but never verifies the type argument is actually an enum. Since `TrivialEnum<T>` has no generic constraint requiring `T... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/semantic_analysis/ast_node/expression/intrinsic_function.rs b/sway-core/src/semantic_analysis/ast_node/expression/intrinsic_function.rs
index 4666c48f85b..350086a32aa 100644
--- a/sway-core/src/semantic_analysis/ast_node/expression/intrinsic_function.rs
+++ b/sway-core/src/semantic_analysis/a... | [
"sway-core/src/semantic_analysis/ast_node/expression/intrinsic_function.rs"
] | [
{
"comment": "### No enum type validation for `EnumDiscriminantCount` intrinsic\n\n**Medium Severity**\n\n<!-- DESCRIPTION START -->\n`type_check_enum_discriminant_count` validates argument count and type argument count but never verifies the type argument is actually an enum. Since `TrivialEnum<T>` has no gene... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### Trivially encodable check defined but never enforced
**Medium Severity**
<!-- DESCRIPTION START -->
`REQUIRE_ARG_NAME_TRIVIALLY_ENCODABLE` is defined and registered as a valid argument for the `#[require]` attribute, but the checking logic in `compile_entry_function` only checks for `REQUIRE_ARG_NAME_TRIVIALLY_DE... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-ast/src/attribute.rs b/sway-ast/src/attribute.rs
index 515d7a43f77..7c26ae939a3 100644
--- a/sway-ast/src/attribute.rs
+++ b/sway-ast/src/attribute.rs
@@ -65,6 +65,11 @@ pub const ABI_NAME_NAME_ARG_NAME: &str = "name";
pub const EVENT_ATTRIBUTE_NAME: &str = "event";
pub const INDEXED_ATTRIBUTE_NAME:... | [
"sway-ast/src/attribute.rs"
] | [
{
"comment": "### Trivially encodable check defined but never enforced\n\n**Medium Severity**\n\n<!-- DESCRIPTION START -->\n`REQUIRE_ARG_NAME_TRIVIALLY_ENCODABLE` is defined and registered as a valid argument for the `#[require]` attribute, but the checking logic in `compile_entry_function` only checks for `RE... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### Encodable require argument is ignored
**Medium Severity**
<!-- DESCRIPTION START -->
`run_ir_decl_checks` only handles `trivially_decodable` and never processes `trivially_encodable`, even though the attribute parser accepts both keys. Using `#[require(trivially_encodable = ...)]` currently performs no validation... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/ir_generation/compile.rs b/sway-core/src/ir_generation/compile.rs
index 1a2b95e9ae3..153d420b6c8 100644
--- a/sway-core/src/ir_generation/compile.rs
+++ b/sway-core/src/ir_generation/compile.rs
@@ -1,32 +1,42 @@
+use super::{
+ const_eval::{compile_const_decl, LookupEnv},
+ convert::con... | [
"sway-core/src/ir_generation/compile.rs"
] | [
{
"comment": "### Encodable require argument is ignored\n\n**Medium Severity**\n\n<!-- DESCRIPTION START -->\n`run_ir_decl_checks` only handles `trivially_decodable` and never processes `trivially_encodable`, even though the attribute parser accepts both keys. Using `#[require(trivially_encodable = ...)]` curre... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### Require allowed on enums but never checked
**Medium Severity**
<!-- DESCRIPTION START -->
`#[require]` is accepted on enums, but enum declarations are excluded from `TypeMetadata::CheckDecl` collection, so enum annotations never reach the checker.
<!-- DESCRIPTION END -->
<!-- BUGBOT_BUG_ID: 42176964-ebb5-4293-8... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/language/ty/declaration/declaration.rs b/sway-core/src/language/ty/declaration/declaration.rs
index f12eeb9fd89..a4888f5c405 100644
--- a/sway-core/src/language/ty/declaration/declaration.rs
+++ b/sway-core/src/language/ty/declaration/declaration.rs
@@ -1,17 +1,17 @@
use crate::{
decl_e... | [
"sway-core/src/language/ty/declaration/declaration.rs"
] | [
{
"comment": "### Require allowed on enums but never checked\n\n**Medium Severity**\n\n<!-- DESCRIPTION START -->\n`#[require]` is accepted on enums, but enum declarations are excluded from `TypeMetadata::CheckDecl` collection, so enum annotations never reach the checker.\n<!-- DESCRIPTION END -->\n\n<!-- BUGBO... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### Const-eval intrinsic branch still unimplemented
**High Severity**
<!-- DESCRIPTION START -->
`Intrinsic::EnumDiscriminantCount` in const-eval calls `todo!()`. Using this intrinsic in any constant-evaluated context will panic the compiler.
<!-- DESCRIPTION END -->
<!-- BUGBOT_BUG_ID: eeabf343-71db-4ae5-beae-0989f... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/ir_generation/const_eval.rs b/sway-core/src/ir_generation/const_eval.rs
index fe5f5613517..86ee30a77f5 100644
--- a/sway-core/src/ir_generation/const_eval.rs
+++ b/sway-core/src/ir_generation/const_eval.rs
@@ -567,44 +567,7 @@ fn const_eval_typed_expr(
fn_ref,
call_p... | [
"sway-core/src/ir_generation/const_eval.rs"
] | [
{
"comment": "### Const-eval intrinsic branch still unimplemented\n\n**High Severity**\n\n<!-- DESCRIPTION START -->\n`Intrinsic::EnumDiscriminantCount` in const-eval calls `todo!()`. Using this intrinsic in any constant-evaluated context will panic the compiler.\n<!-- DESCRIPTION END -->\n\n<!-- BUGBOT_BUG_ID:... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### `EnumVariantsValues` intrinsic hardcodes `true` for all variants
**High Severity**
<!-- DESCRIPTION START -->
The `EnumVariantsValues` intrinsic always returns `true` for every enum variant via `ConstantContent::new_bool(context, true)`, ignoring whether each variant is actually trivially decodable. This defeats ... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/ir_generation/function.rs b/sway-core/src/ir_generation/function.rs
index 2169d4aa07c..79cd8c73610 100644
--- a/sway-core/src/ir_generation/function.rs
+++ b/sway-core/src/ir_generation/function.rs
@@ -28,9 +28,13 @@ use crate::{
types::*,
PanicOccurrence, PanicOccurrences, Panickin... | [
"sway-core/src/ir_generation/function.rs"
] | [
{
"comment": "### `EnumVariantsValues` intrinsic hardcodes `true` for all variants\n\n**High Severity**\n\n<!-- DESCRIPTION START -->\nThe `EnumVariantsValues` intrinsic always returns `true` for every enum variant via `ConstantContent::new_bool(context, true)`, ignoring whether each variant is actually trivial... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### Type check hardcodes literal `3`, panics otherwise
**High Severity**
<!-- DESCRIPTION START -->
`type_check_enum_variants_values` only accepts the literal value `3` as the first argument and panics with `todo!()` for any other value. This makes the intrinsic unusable for general purposes and will crash the compil... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/semantic_analysis/ast_node/expression/intrinsic_function.rs b/sway-core/src/semantic_analysis/ast_node/expression/intrinsic_function.rs
index 4666c48f85b..350086a32aa 100644
--- a/sway-core/src/semantic_analysis/ast_node/expression/intrinsic_function.rs
+++ b/sway-core/src/semantic_analysis/a... | [
"sway-core/src/semantic_analysis/ast_node/expression/intrinsic_function.rs"
] | [
{
"comment": "### Type check hardcodes literal `3`, panics otherwise\n\n**High Severity**\n\n<!-- DESCRIPTION START -->\n`type_check_enum_variants_values` only accepts the literal value `3` as the first argument and panics with `todo!()` for any other value. This makes the intrinsic unusable for general purpose... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### Out-of-bounds access before bounds check in `is_valid`
**High Severity**
<!-- DESCRIPTION START -->
In `TrivialEnum::is_valid`, `__elem_at(is_decode_trivial_table, discriminant)` accesses the slice at the discriminant index *before* the bounds check `discriminant < is_decode_trivial_table.len()` is evaluated. Whe... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-lib-std/src/codec.sw b/sway-lib-std/src/codec.sw
index 32bb8ef5e88..e5527835fb9 100644
--- a/sway-lib-std/src/codec.sw
+++ b/sway-lib-std/src/codec.sw
@@ -3,6 +3,8 @@ library;
use ::ops::*;
use ::raw_ptr::*;
use ::raw_slice::*;
+use ::slice::*;
+use ::error_signals::*;
pub struct Buffer {
b... | [
"sway-lib-std/src/codec.sw"
] | [
{
"comment": "### Out-of-bounds access before bounds check in `is_valid`\n\n**High Severity**\n\n<!-- DESCRIPTION START -->\nIn `TrivialEnum::is_valid`, `__elem_at(is_decode_trivial_table, discriminant)` accesses the slice at the discriminant index *before* the bounds check `discriminant < is_decode_trivial_tab... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### Wrong expected argument count in error message
**Medium Severity**
<!-- DESCRIPTION START -->
In `type_check_enum_variants_values`, the check `arguments.len() != 1` correctly validates that exactly one argument is needed, but the error reports `expected: 0`. The error message will mislead users into passing zero ... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/semantic_analysis/ast_node/expression/intrinsic_function.rs b/sway-core/src/semantic_analysis/ast_node/expression/intrinsic_function.rs
index 4666c48f85b..350086a32aa 100644
--- a/sway-core/src/semantic_analysis/ast_node/expression/intrinsic_function.rs
+++ b/sway-core/src/semantic_analysis/a... | [
"sway-core/src/semantic_analysis/ast_node/expression/intrinsic_function.rs"
] | [
{
"comment": "### Wrong expected argument count in error message\n\n**Medium Severity**\n\n<!-- DESCRIPTION START -->\nIn `type_check_enum_variants_values`, the check `arguments.len() != 1` correctly validates that exactly one argument is needed, but the error reports `expected: 0`. The error message will misle... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### TrivialEnum abi_encode silently discards the inner value
**Medium Severity**
<!-- DESCRIPTION START -->
`TrivialEnum<T>`'s `abi_encode` returns the buffer unchanged without encoding `self.value`. While the trivial encoding path bypasses this method via memcpy, if `abi_encode` is ever called through the non-trivia... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-lib-std/src/codec.sw b/sway-lib-std/src/codec.sw
index 32bb8ef5e88..e5527835fb9 100644
--- a/sway-lib-std/src/codec.sw
+++ b/sway-lib-std/src/codec.sw
@@ -3,6 +3,8 @@ library;
use ::ops::*;
use ::raw_ptr::*;
use ::raw_slice::*;
+use ::slice::*;
+use ::error_signals::*;
pub struct Buffer {
b... | [
"sway-lib-std/src/codec.sw"
] | [
{
"comment": "### TrivialEnum abi_encode silently discards the inner value\n\n**Medium Severity**\n\n<!-- DESCRIPTION START -->\n`TrivialEnum<T>`'s `abi_encode` returns the buffer unchanged without encoding `self.value`. While the trivial encoding path bypasses this method via memcpy, if `abi_encode` is ever ca... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### Debug trait bound added to monomorphize functions unnecessarily
**Low Severity**
<!-- DESCRIPTION START -->
The `std::fmt::Debug` trait bound was added to `monomorphize` and `monomorphize_with_modpath` generic type parameters. This exists solely to support the commented-out `eprintln!` debug statements in `functi... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/type_system/monomorphization.rs b/sway-core/src/type_system/monomorphization.rs
index 70871ea15ba..80327e179bb 100644
--- a/sway-core/src/type_system/monomorphization.rs
+++ b/sway-core/src/type_system/monomorphization.rs
@@ -276,12 +276,8 @@ where
subst_ctx,
)?;
- value.su... | [
"sway-core/src/type_system/monomorphization.rs"
] | [
{
"comment": "### Debug trait bound added to monomorphize functions unnecessarily\n\n**Low Severity**\n\n<!-- DESCRIPTION START -->\nThe `std::fmt::Debug` trait bound was added to `monomorphize` and `monomorphize_with_modpath` generic type parameters. This exists solely to support the commented-out `eprintln!` ... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### Commented-out debug eprintln statements left in code
**Low Severity**
<!-- DESCRIPTION START -->
Multiple commented-out `//eprintln!` debug statements were added across `function_application.rs` (lines 30 and 101) and `method_application.rs` (line 1017). These are development-time debugging artifacts that clutter... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/function_application.rs b/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/function_application.rs
index 0f75245398d..288b068983e 100644
--- a/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/functi... | [
"sway-core/src/semantic_analysis/ast_node/expression/typed_expression/function_application.rs"
] | [
{
"comment": "### Commented-out debug eprintln statements left in code\n\n**Low Severity**\n\n<!-- DESCRIPTION START -->\nMultiple commented-out `//eprintln!` debug statements were added across `function_application.rs` (lines 30 and 101) and `method_application.rs` (line 1017). These are development-time debug... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### Vec/String help messages never shown due to path mismatch
**Medium Severity**
<!-- DESCRIPTION START -->
The special-case help messages for `Vec` and `String` types are never triggered. The checks use fully-qualified paths (`std::vec::Vec<` and `std::string::String`) but `type_as_in_src` comes from `span.as_str()... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/ir_generation/compile.rs b/sway-core/src/ir_generation/compile.rs
index 1a2b95e9ae3..153d420b6c8 100644
--- a/sway-core/src/ir_generation/compile.rs
+++ b/sway-core/src/ir_generation/compile.rs
@@ -1,32 +1,42 @@
+use super::{
+ const_eval::{compile_const_decl, LookupEnv},
+ convert::con... | [
"sway-core/src/ir_generation/compile.rs"
] | [
{
"comment": "### Vec/String help messages never shown due to path mismatch\n\n**Medium Severity**\n\n<!-- DESCRIPTION START -->\nThe special-case help messages for `Vec` and `String` types are never triggered. The checks use fully-qualified paths (`std::vec::Vec<` and `std::string::String`) but `type_as_in_src... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### Recursive struct metadata collection may cause infinite loop
**Medium Severity**
<!-- DESCRIPTION START -->
The new `TypeInfo::Struct` arm in `CollectTypesMetadata for TypeId` calls `TyDecl::StructDecl(...).collect_types_metadata()`, which in turn inspects fields' type IDs. Since `extract_any_including_self` recu... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/type_system/id.rs b/sway-core/src/type_system/id.rs
index 6a17fc1aab6..de6cbd9e75a 100644
--- a/sway-core/src/type_system/id.rs
+++ b/sway-core/src/type_system/id.rs
@@ -12,7 +12,10 @@ use crate::{
DeclEngineGet, DeclEngineGetParsedDecl, DeclEngineInsert, MaterializeConstGenerics,
... | [
"sway-core/src/type_system/id.rs"
] | [
{
"comment": "### Recursive struct metadata collection may cause infinite loop\n\n**Medium Severity**\n\n<!-- DESCRIPTION START -->\nThe new `TypeInfo::Struct` arm in `CollectTypesMetadata for TypeId` calls `TyDecl::StructDecl(...).collect_types_metadata()`, which in turn inspects fields' type IDs. Since `extra... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### `generate_tables` silently swallows parse/compilation errors
**Medium Severity**
<!-- DESCRIPTION START -->
`generate_tables` calls `parse_impl_trait_to_ty_ast_node(...).ok()`, silently discarding any parse or compilation errors when generating the `EnumCodecValues` implementation. If the auto-generated code is m... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/semantic_analysis/ast_node/declaration/auto_impl/abi_encoding.rs b/sway-core/src/semantic_analysis/ast_node/declaration/auto_impl/abi_encoding.rs
index 6a7ab2ce415..ffc797b4774 100644
--- a/sway-core/src/semantic_analysis/ast_node/declaration/auto_impl/abi_encoding.rs
+++ b/sway-core/src/sema... | [
"sway-core/src/semantic_analysis/ast_node/declaration/auto_impl/abi_encoding.rs"
] | [
{
"comment": "### `generate_tables` silently swallows parse/compilation errors\n\n**Medium Severity**\n\n<!-- DESCRIPTION START -->\n`generate_tables` calls `parse_impl_trait_to_ty_ast_node(...).ok()`, silently discarding any parse or compilation errors when generating the `EnumCodecValues` implementation. If t... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### HashMap `unwrap()` panics when type key is missing
**High Severity**
<!-- DESCRIPTION START -->
`table.get(&fullname).unwrap()` and `table.get(&field_fullname).unwrap()` will panic if the type's name is absent from the table. The table is built via `filter_map` in `run_ir_decl_checks` (lines 627–636), which silen... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/ir_generation/compile.rs b/sway-core/src/ir_generation/compile.rs
index 1a2b95e9ae3..153d420b6c8 100644
--- a/sway-core/src/ir_generation/compile.rs
+++ b/sway-core/src/ir_generation/compile.rs
@@ -1,32 +1,42 @@
+use super::{
+ const_eval::{compile_const_decl, LookupEnv},
+ convert::con... | [
"sway-core/src/ir_generation/compile.rs"
] | [
{
"comment": "### HashMap `unwrap()` panics when type key is missing\n\n**High Severity**\n\n<!-- DESCRIPTION START -->\n`table.get(&fullname).unwrap()` and `table.get(&field_fullname).unwrap()` will panic if the type's name is absent from the table. The table is built via `filter_map` in `run_ir_decl_checks` (... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### `todo!()` in production code panics on unexpected types
**Medium Severity**
<!-- DESCRIPTION START -->
Two `todo!()` macros in the `check_type` closure (line 1171) and `push_help_if_non_trivially_decodable_type` (line 768) will panic at runtime if an unexpected `TypeInfo` variant is encountered. These are reachab... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/lib.rs b/sway-core/src/lib.rs
index 9a1c701bccc..9cffb101efb 100644
--- a/sway-core/src/lib.rs
+++ b/sway-core/src/lib.rs
@@ -26,11 +26,18 @@ pub mod source_map;
pub mod transform;
pub mod type_system;
+use crate::decl_engine::DeclEngineGet as _;
+use crate::engine_threading::SpannedWithE... | [
"sway-core/src/lib.rs"
] | [
{
"comment": "### `todo!()` in production code panics on unexpected types\n\n**Medium Severity**\n\n<!-- DESCRIPTION START -->\nTwo `todo!()` macros in the `check_type` closure (line 1171) and `push_help_if_non_trivially_decodable_type` (line 768) will panic at runtime if an unexpected `TypeInfo` variant is enc... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### Shadowed MetadataManager discards state from decl checks context
**Medium Severity**
<!-- DESCRIPTION START -->
A `MetadataManager` is created at line 951 and mutated by `run_decl_checks`, but then a second `let mut md_mgr = MetadataManager::default()` at line 1040 shadows it. Meanwhile, the same `ctx` (IR `Conte... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/lib.rs b/sway-core/src/lib.rs
index 9a1c701bccc..9cffb101efb 100644
--- a/sway-core/src/lib.rs
+++ b/sway-core/src/lib.rs
@@ -26,11 +26,18 @@ pub mod source_map;
pub mod transform;
pub mod type_system;
+use crate::decl_engine::DeclEngineGet as _;
+use crate::engine_threading::SpannedWithE... | [
"sway-core/src/lib.rs"
] | [
{
"comment": "### Shadowed MetadataManager discards state from decl checks context\n\n**Medium Severity**\n\n<!-- DESCRIPTION START -->\nA `MetadataManager` is created at line 951 and mutated by `run_decl_checks`, but then a second `let mut md_mgr = MetadataManager::default()` at line 1040 shadows it. Meanwhile... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### `TrivialBool` methods missing `pub` visibility modifier
**High Severity**
<!-- DESCRIPTION START -->
`TrivialBool`'s `is_valid` and `unwrap` methods are missing the `pub` keyword, making them inaccessible to external users. The documentation explicitly shows users calling `.unwrap()` on `TrivialBool` values. The ... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-lib-std/src/codec.sw b/sway-lib-std/src/codec.sw
index 32bb8ef5e88..e5527835fb9 100644
--- a/sway-lib-std/src/codec.sw
+++ b/sway-lib-std/src/codec.sw
@@ -3,6 +3,8 @@ library;
use ::ops::*;
use ::raw_ptr::*;
use ::raw_slice::*;
+use ::slice::*;
+use ::error_signals::*;
pub struct Buffer {
b... | [
"sway-lib-std/src/codec.sw"
] | [
{
"comment": "### `TrivialBool` methods missing `pub` visibility modifier\n\n**High Severity**\n\n<!-- DESCRIPTION START -->\n`TrivialBool`'s `is_valid` and `unwrap` methods are missing the `pub` keyword, making them inaccessible to external users. The documentation explicitly shows users calling `.unwrap()` on... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | nit: I'd prefer to have the decl handled with an enum, so that the `unwrap()` below becomes unnecessary. Perhaps something like this:
```rust
enum Ty {
Ref(Span),
Decl,
}
``` | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/lib.rs b/sway-core/src/lib.rs
index 9a1c701bccc..9cffb101efb 100644
--- a/sway-core/src/lib.rs
+++ b/sway-core/src/lib.rs
@@ -26,11 +26,18 @@ pub mod source_map;
pub mod transform;
pub mod type_system;
+use crate::decl_engine::DeclEngineGet as _;
+use crate::engine_threading::SpannedWithE... | [
"sway-core/src/lib.rs"
] | [
{
"comment": "nit: I'd prefer to have the decl handled with an enum, so that the `unwrap()` below becomes unnecessary. Perhaps something like this:\n\n```rust\nenum Ty {\n Ref(Span),\n Decl,\n}\n```",
"path": "sway-core/src/lib.rs",
"hunk": "@@ -1050,6 +1078,195 @@ pub fn parsed_to_ast(\n Ok(t... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | typo: "aray" | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/ir_generation/compile.rs b/sway-core/src/ir_generation/compile.rs
index 1a2b95e9ae3..153d420b6c8 100644
--- a/sway-core/src/ir_generation/compile.rs
+++ b/sway-core/src/ir_generation/compile.rs
@@ -1,32 +1,42 @@
+use super::{
+ const_eval::{compile_const_decl, LookupEnv},
+ convert::con... | [
"sway-core/src/ir_generation/compile.rs"
] | [
{
"comment": "typo: \"aray\"",
"path": "sway-core/src/ir_generation/compile.rs",
"hunk": "@@ -576,6 +575,300 @@ pub(super) fn compile_entry_function(\n .map(|f| f.expect(\"entry point should never contain generics\"))\n }\n \n+#[derive(Debug, Clone)]\n+pub enum CheckDecl {\n+ Ref {\n+ tid:... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | This breaks if any nested types are generic | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/ir_generation/compile.rs b/sway-core/src/ir_generation/compile.rs
index 1a2b95e9ae3..153d420b6c8 100644
--- a/sway-core/src/ir_generation/compile.rs
+++ b/sway-core/src/ir_generation/compile.rs
@@ -1,32 +1,42 @@
+use super::{
+ const_eval::{compile_const_decl, LookupEnv},
+ convert::con... | [
"sway-core/src/ir_generation/compile.rs"
] | [
{
"comment": "This breaks if any nested types are generic",
"path": "sway-core/src/ir_generation/compile.rs",
"hunk": "@@ -576,6 +575,300 @@ pub(super) fn compile_entry_function(\n .map(|f| f.expect(\"entry point should never contain generics\"))\n }\n \n+#[derive(Debug, Clone)]\n+pub enum CheckDecl... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | It looks like this is never used? | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-error/src/error.rs b/sway-error/src/error.rs
index 97d77fe44de..c4693cecfbc 100644
--- a/sway-error/src/error.rs
+++ b/sway-error/src/error.rs
@@ -9,6 +9,7 @@ use crate::parser_error::{ParseError, ParseErrorKind};
use crate::type_error::TypeError;
use core::fmt;
+use std::collections::BTreeSet;
u... | [
"sway-error/src/error.rs"
] | [
{
"comment": "It looks like this is never used?",
"path": "sway-error/src/error.rs",
"hunk": "@@ -501,6 +502,8 @@ pub enum CompileError {\n },\n #[error(\"This opcode takes an immediate value but none was provided.\")]\n MissingImmediate { span: Span },\n+ #[error(\"Invalid argument.\")]\... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### Debug statement left in production code
**High Severity**
<!-- DESCRIPTION START -->
A `dbg!()` macro was left in production code inside `prepare_const_generics_materialization`. This will print debug output to stderr during normal compilation whenever a const generic parameter's argument type is `None`, which po... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/method_application.rs b/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/method_application.rs
index b15c620e47c..2b06d55297a 100644
--- a/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/method_app... | [
"sway-core/src/semantic_analysis/ast_node/expression/typed_expression/method_application.rs"
] | [
{
"comment": "### Debug statement left in production code\n\n**High Severity**\n\n<!-- DESCRIPTION START -->\nA `dbg!()` macro was left in production code inside `prepare_const_generics_materialization`. This will print debug output to stderr during normal compilation whenever a const generic parameter's argume... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### Unhandled `todo!()` panics in indexing compilation
**Medium Severity**
<!-- DESCRIPTION START -->
The `compile_indexing` method uses `todo!()` for two fallback match arms: when a `TypedPointer` points to something other than an array, and when the prefix type is neither a `TypedPointer` nor a `TypedSlice`. These ... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/ir_generation/function.rs b/sway-core/src/ir_generation/function.rs
index 2169d4aa07c..79cd8c73610 100644
--- a/sway-core/src/ir_generation/function.rs
+++ b/sway-core/src/ir_generation/function.rs
@@ -28,9 +28,13 @@ use crate::{
types::*,
PanicOccurrence, PanicOccurrences, Panickin... | [
"sway-core/src/ir_generation/function.rs"
] | [
{
"comment": "### Unhandled `todo!()` panics in indexing compilation\n\n**Medium Severity**\n\n<!-- DESCRIPTION START -->\nThe `compile_indexing` method uses `todo!()` for two fallback match arms: when a `TypedPointer` points to something other than an array, and when the prefix type is neither a `TypedPointer`... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | ### Debug `todo!()` with backtrace replaces `unreachable!()`
**High Severity**
<!-- DESCRIPTION START -->
The previous `unreachable!()` was replaced with `todo!("{x:?} {}", std::backtrace::Backtrace::force_capture())`. This is clearly debugging code — it captures a full backtrace at runtime (which is expensive) and u... | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/semantic_analysis/type_resolve.rs b/sway-core/src/semantic_analysis/type_resolve.rs
index 317d73925b2..f760a4cfbae 100644
--- a/sway-core/src/semantic_analysis/type_resolve.rs
+++ b/sway-core/src/semantic_analysis/type_resolve.rs
@@ -61,7 +61,11 @@ fn resolve_length(
let decl = m... | [
"sway-core/src/semantic_analysis/type_resolve.rs"
] | [
{
"comment": "### Debug `todo!()` with backtrace replaces `unreachable!()`\n\n**High Severity**\n\n<!-- DESCRIPTION START -->\nThe previous `unreachable!()` was replaced with `todo!(\"{x:?} {}\", std::backtrace::Backtrace::force_capture())`. This is clearly debugging code — it captures a full backtrace at runti... | true | ||
FuelLabs/sway | 7,575 | comment_to_fix | Attribute for checking of trivial encoding and decoding | `at_most(2)` allows zero args, e.g., having just `#[require]`. This must be between 1 and 2.
```suggestion
Require => Multiplicity::between(1, 2),
``` | 9e8750e0f618b460b7e7c88af3b690f15ae9d12d | 094041d5f9a37889918e867ae39e6addba61f3c4 | diff --git a/sway-core/src/transform/attribute.rs b/sway-core/src/transform/attribute.rs
index fd144d75441..1cb764ecb54 100644
--- a/sway-core/src/transform/attribute.rs
+++ b/sway-core/src/transform/attribute.rs
@@ -358,6 +358,7 @@ pub enum AttributeKind {
AbiName,
Event,
Indexed,
+ Require,
}
//... | [
"sway-core/src/transform/attribute.rs"
] | [
{
"comment": "`at_most(2)` allows zero args, e.g., having just `#[require]`. This must be between 1 and 2.\n```suggestion\n Require => Multiplicity::between(1, 2),\n```",
"path": "sway-core/src/transform/attribute.rs",
"hunk": "@@ -469,6 +472,7 @@ impl Attribute {\n AbiName => Mul... | true | ||
FuelLabs/sway | 7,626 | issue_to_patch | Add comprehensive in-language tests for all storage types | ## Description
This PR adds in-language tests for all all storage types, except for `StorageKey` and `StorageVec`, which are added in #7614.
Existing SDK harness tests that were testing the same functionality are deleted. This is aligned with the decision to migrate SDK harness tests to in-language tests and and ... | ce310eb1b5abad4a885af393559834afe7f18716 | 19e8fbb7f2bae5aa0733fd5c7e0b0f4be31e504a | [
"test/src/in_language_tests/test_programs/storage_bytes_contract_tests/Forc.toml",
"test/src/in_language_tests/test_programs/storage_bytes_contract_tests/src/main.sw",
"test/src/in_language_tests/test_programs/storage_map_contract_tests/Forc.toml",
"test/src/in_language_tests/test_programs/storage_map_contrac... | [] | diff --git a/test/src/sdk-harness/test_projects/storage_string/Forc.toml b/test/src/in_language_tests/test_programs/storage_bytes_contract_tests/Forc.toml
similarity index 80%
rename from test/src/sdk-harness/test_projects/storage_string/Forc.toml
rename to test/src/in_language_tests/test_programs/storage_bytes_contrac... | true | ||
FuelLabs/sway | 7,582 | issue_to_patch | Optimize encoding and decoding of `Vec<T>` when `T` is trivial | ## Description
This PR optimizes the encoding and decoding of `std::vec::Vec::<T>` when `T` is a trivially encodable and decodable type. In that case, we don't have encode each element individually, but just encode the vector's length and mem-copy its content to the `Buffer`.
## Checklist
- [ ] I have linked ... | c1600d30409941616330b0dff70fec14435da9a3 | 2a991efd623ecab749d2a36791ec55e3dfafeb62 | diff --git a/sway-core/src/ir_generation/function.rs b/sway-core/src/ir_generation/function.rs
index 812d8fe0a82..2169d4aa07c 100644
--- a/sway-core/src/ir_generation/function.rs
+++ b/sway-core/src/ir_generation/function.rs
@@ -2056,534 +2056,7 @@ impl<'a> FnCompiler<'a> {
Ok(TerminatorValue::new(buff... | [
"sway-core/src/ir_generation/function.rs",
"sway-core/src/semantic_analysis/ast_node/expression/intrinsic_function.rs",
"sway-error/src/error.rs",
"sway-lib-std/src/codec.sw",
"sway-lib-std/src/error_signals.sw",
"sway-lib-std/src/raw_slice.sw",
"sway-lib-std/src/vec.sw",
"test/src/e2e_vm_tests/reduce... | [
{
"comment": "### Test `vec_non_trivial` incorrectly tests trivial path instead\n\n**Medium Severity**\n\n<!-- DESCRIPTION START -->\nThe `vec_non_trivial` test calls `create_vec_trivial(10)` and uses `Vec<u64>`, making it an exact duplicate of `vec_trivial`. It was clearly intended to call `create_vec_non_triv... | diff --git a/test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core/reduced_lib.config b/test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core/reduced_lib.config
index 5087306b772..2edfa037c21 100644
--- a/test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core/reduced_lib.config
+++ b/test/src/e2e_vm_tests/reduc... | true | |
FuelLabs/sway | 7,582 | comment_to_fix | Optimize encoding and decoding of `Vec<T>` when `T` is trivial | ### Test `vec_non_trivial` incorrectly tests trivial path instead
**Medium Severity**
<!-- DESCRIPTION START -->
The `vec_non_trivial` test calls `create_vec_trivial(10)` and uses `Vec<u64>`, making it an exact duplicate of `vec_trivial`. It was clearly intended to call `create_vec_non_trivial(10)` and use `Vec<u32>`... | c1600d30409941616330b0dff70fec14435da9a3 | 2a991efd623ecab749d2a36791ec55e3dfafeb62 | diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_encoding_decoding/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_encoding_decoding/src/main.sw
new file mode 100644
index 00000000000..dbb392a42fa
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/... | [
"test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_encoding_decoding/src/main.sw"
] | [
{
"comment": "### Test `vec_non_trivial` incorrectly tests trivial path instead\n\n**Medium Severity**\n\n<!-- DESCRIPTION START -->\nThe `vec_non_trivial` test calls `create_vec_trivial(10)` and uses `Vec<u64>`, making it an exact duplicate of `vec_trivial`. It was clearly intended to call `create_vec_non_triv... | true | ||
FuelLabs/sway | 7,582 | comment_to_fix | Optimize encoding and decoding of `Vec<T>` when `T` is trivial | ### Script test data incompatible with new trivial encoding format
**High Severity**
<!-- DESCRIPTION START -->
The `script_data_new_encoding` encodes `Vec<u64>` with an element-count length prefix (`0000000000000003` = 3), but the new trivial decode path uses `raw_slice::abi_decode` which interprets the prefix as a ... | c1600d30409941616330b0dff70fec14435da9a3 | 2a991efd623ecab749d2a36791ec55e3dfafeb62 | diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_encoding_decoding/test.run.toml b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_encoding_decoding/test.run.toml
new file mode 100644
index 00000000000..e3e7741a9ab
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/std... | [
"test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_encoding_decoding/test.run.toml"
] | [
{
"comment": "### Script test data incompatible with new trivial encoding format\n\n**High Severity**\n\n<!-- DESCRIPTION START -->\nThe `script_data_new_encoding` encodes `Vec<u64>` with an element-count length prefix (`0000000000000003` = 3), but the new trivial decode path uses `raw_slice::abi_decode` which ... | true | ||
FuelLabs/sway | 7,582 | comment_to_fix | Optimize encoding and decoding of `Vec<T>` when `T` is trivial | Because we currently don't support neither inline modules nor something like `#[cfg(test = true)` having test types and impls in modules bloats the module and is actually confusing 😞 I was confused at first when encountering `NonTrivial` I thought it is some actual type and not a test dummy.
That's why I would propos... | c1600d30409941616330b0dff70fec14435da9a3 | 2a991efd623ecab749d2a36791ec55e3dfafeb62 | diff --git a/sway-lib-std/src/vec.sw b/sway-lib-std/src/vec.sw
index c0f0c94a96b..0071e496ac8 100644
--- a/sway-lib-std/src/vec.sw
+++ b/sway-lib-std/src/vec.sw
@@ -1,7 +1,7 @@
//! A vector type for dynamically sized arrays outside of storage.
library;
-use ::alloc::{alloc, realloc};
+use ::alloc::{alloc, alloc_byt... | [
"sway-lib-std/src/vec.sw"
] | [
{
"comment": "Because we currently don't support neither inline modules nor something like `#[cfg(test = true)` having test types and impls in modules bloats the module and is actually confusing 😞 I was confused at first when encountering `NonTrivial` I thought it is some actual type and not a test dummy.\n\nT... | true | ||
FuelLabs/sway | 7,582 | comment_to_fix | Optimize encoding and decoding of `Vec<T>` when `T` is trivial | Nitpick. The body of `vec_encode_trivial` and `vec_encode_non_trivial` is essentially the same. We can have one generic `test_vec_encode<T>(v1: T, v2: T)` here and call it in both tests. | c1600d30409941616330b0dff70fec14435da9a3 | 2a991efd623ecab749d2a36791ec55e3dfafeb62 | diff --git a/sway-lib-std/src/vec.sw b/sway-lib-std/src/vec.sw
index c0f0c94a96b..0071e496ac8 100644
--- a/sway-lib-std/src/vec.sw
+++ b/sway-lib-std/src/vec.sw
@@ -1,7 +1,7 @@
//! A vector type for dynamically sized arrays outside of storage.
library;
-use ::alloc::{alloc, realloc};
+use ::alloc::{alloc, alloc_byt... | [
"sway-lib-std/src/vec.sw"
] | [
{
"comment": "Nitpick. The body of `vec_encode_trivial` and `vec_encode_non_trivial` is essentially the same. We can have one generic `test_vec_encode<T>(v1: T, v2: T)` here and call it in both tests.",
"path": "sway-lib-std/src/vec.sw",
"hunk": "@@ -933,3 +944,71 @@ where\n l.finish();\n }\... | true | ||
FuelLabs/sway | 7,582 | comment_to_fix | Optimize encoding and decoding of `Vec<T>` when `T` is trivial | A corner case that IMO should be covered in tests is having a **zero-sized** `T` once trivial, once non-trivial. Maybe just a reason more than for having a once defined `test_vec_encode<T>(v1: T, v2: T)` 🤔 | c1600d30409941616330b0dff70fec14435da9a3 | 2a991efd623ecab749d2a36791ec55e3dfafeb62 | diff --git a/sway-lib-std/src/vec.sw b/sway-lib-std/src/vec.sw
index c0f0c94a96b..0071e496ac8 100644
--- a/sway-lib-std/src/vec.sw
+++ b/sway-lib-std/src/vec.sw
@@ -1,7 +1,7 @@
//! A vector type for dynamically sized arrays outside of storage.
library;
-use ::alloc::{alloc, realloc};
+use ::alloc::{alloc, alloc_byt... | [
"sway-lib-std/src/vec.sw"
] | [
{
"comment": "A corner case that IMO should be covered in tests is having a **zero-sized** `T` once trivial, once non-trivial. Maybe just a reason more than for having a once defined `test_vec_encode<T>(v1: T, v2: T)` 🤔 ",
"path": "sway-lib-std/src/vec.sw",
"hunk": "@@ -933,3 +944,71 @@ where\n ... | true | ||
FuelLabs/sway | 7,582 | comment_to_fix | Optimize encoding and decoding of `Vec<T>` when `T` is trivial | We need to update the error message in `error.rs` as well.
Proposal:
Only bool, u8, u16, u32, u64, u256, b256, string arrays, string slices, and (raw_ptr, u64) can be used here.
| c1600d30409941616330b0dff70fec14435da9a3 | 2a991efd623ecab749d2a36791ec55e3dfafeb62 | diff --git a/sway-core/src/semantic_analysis/ast_node/expression/intrinsic_function.rs b/sway-core/src/semantic_analysis/ast_node/expression/intrinsic_function.rs
index 012ceb4c038..4666c48f85b 100644
--- a/sway-core/src/semantic_analysis/ast_node/expression/intrinsic_function.rs
+++ b/sway-core/src/semantic_analysis/a... | [
"sway-core/src/semantic_analysis/ast_node/expression/intrinsic_function.rs"
] | [
{
"comment": "We need to update the error message in `error.rs` as well.\n\nProposal:\nOnly bool, u8, u16, u32, u64, u256, b256, string arrays, string slices, and (raw_ptr, u64) can be used here.\n\n\n",
"path": "sway-core/src/semantic_analysis/ast_node/expression/intrinsic_function.rs",
"hunk": "@@ -73... | true | ||
FuelLabs/sway | 7,582 | comment_to_fix | Optimize encoding and decoding of `Vec<T>` when `T` is trivial | Everywhere in the `std` we have `[_]revert(0)`, except for the very few `.._SIGNAL` constants.
This is IMO one of the most problematic decisions in the current error handling, complete lack of any additional information on most of the reverts 😞
From that perspective, I am more for `999` than `0`, but breaking the p... | c1600d30409941616330b0dff70fec14435da9a3 | 2a991efd623ecab749d2a36791ec55e3dfafeb62 | diff --git a/sway-lib-std/src/raw_slice.sw b/sway-lib-std/src/raw_slice.sw
index bb1f8e265b4..e56d7effda0 100644
--- a/sway-lib-std/src/raw_slice.sw
+++ b/sway-lib-std/src/raw_slice.sw
@@ -2,6 +2,7 @@ library;
use ::ops::*;
use ::raw_ptr::*;
+use ::error_signals::REVERT_WITH_RAW_SLICE_LEN_ZST;
/// Trait to retur... | [
"sway-lib-std/src/raw_slice.sw"
] | [
{
"comment": "Everywhere in the `std` we have `[_]revert(0)`, except for the very few `.._SIGNAL` constants.\n\nThis is IMO one of the most problematic decisions in the current error handling, complete lack of any additional information on most of the reverts 😞 \n\nFrom that perspective, I am more for `999` th... | true | ||
FuelLabs/sway | 7,582 | comment_to_fix | Optimize encoding and decoding of `Vec<T>` when `T` is trivial | We need to document the revert condition.
```suggestion
///
/// # Reverts
///
/// * When `T` is a zero-sized type.
///
``` | c1600d30409941616330b0dff70fec14435da9a3 | 2a991efd623ecab749d2a36791ec55e3dfafeb62 | diff --git a/sway-lib-std/src/raw_slice.sw b/sway-lib-std/src/raw_slice.sw
index bb1f8e265b4..e56d7effda0 100644
--- a/sway-lib-std/src/raw_slice.sw
+++ b/sway-lib-std/src/raw_slice.sw
@@ -2,6 +2,7 @@ library;
use ::ops::*;
use ::raw_ptr::*;
+use ::error_signals::REVERT_WITH_RAW_SLICE_LEN_ZST;
/// Trait to retur... | [
"sway-lib-std/src/raw_slice.sw"
] | [
{
"comment": "We need to document the revert condition.\n```suggestion\n ///\n /// # Reverts\n ///\n /// * When `T` is a zero-sized type.\n ///\n```",
"path": "sway-lib-std/src/raw_slice.sw",
"hunk": "",
"resolving_sha": "2a991efd623ecab749d2a36791ec55e3dfafeb62",
"resolving_diff"... | true | ||
FuelLabs/sway | 7,620 | issue_to_patch | Fix `Vec` with ZSTs | ## Description
Fix a bug on `Vec` on ZST.
## Checklist
- [ ] I have linked to any relevant issues.
- [x] I have commented my code, particularly in hard-to-understand areas.
- [ ] I have updated the documentation where relevant (API docs, the reference, and the Sway book).
- [ ] If my change requires subs... | b0a91271a06042763b2f62a058141edcfa06cb5f | 69ac773306a480b5013bc9fe53af650da8b54f04 | diff --git a/sway-core/src/ir_generation/function.rs b/sway-core/src/ir_generation/function.rs
index b3089c62be5..812d8fe0a82 100644
--- a/sway-core/src/ir_generation/function.rs
+++ b/sway-core/src/ir_generation/function.rs
@@ -4068,26 +4068,88 @@ impl<'a> FnCompiler<'a> {
// Compile the struct expression.
... | [
"sway-core/src/ir_generation/function.rs",
"sway-ir/src/instruction.rs",
"sway-ir/src/optimize/init_aggr_lowering.rs",
"sway-lib-std/src/raw_ptr.sw",
"test/src/e2e_vm_tests/test_programs/should_pass/language/intrinsics/dbg/stdout.snap",
"test/src/e2e_vm_tests/test_programs/should_pass/language/logging/std... | [
{
"comment": "I think this is fine because this is a debug build.",
"path": "test/src/e2e_vm_tests/test_programs/should_pass/language/intrinsics/dbg/stdout.snap",
"hunk": "@@ -71,12 +71,12 @@ output:\n Building test/src/e2e_vm_tests/test_programs/should_pass/language/intrinsics/dbg\n Compiling li... | diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/intrinsics/dbg/stdout.snap b/test/src/e2e_vm_tests/test_programs/should_pass/language/intrinsics/dbg/stdout.snap
index faafb9f67a3..e9729e9656c 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/intrinsics/dbg/stdout.snap
+++ b/tes... | true | |
FuelLabs/sway | 7,620 | comment_to_fix | Fix `Vec` with ZSTs | I think this is fine because this is a debug build. | b0a91271a06042763b2f62a058141edcfa06cb5f | 69ac773306a480b5013bc9fe53af650da8b54f04 | diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/intrinsics/dbg/stdout.snap b/test/src/e2e_vm_tests/test_programs/should_pass/language/intrinsics/dbg/stdout.snap
index faafb9f67a3..e9729e9656c 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/intrinsics/dbg/stdout.snap
+++ b/tes... | [
"test/src/e2e_vm_tests/test_programs/should_pass/language/intrinsics/dbg/stdout.snap"
] | [
{
"comment": "I think this is fine because this is a debug build.",
"path": "test/src/e2e_vm_tests/test_programs/should_pass/language/intrinsics/dbg/stdout.snap",
"hunk": "@@ -71,12 +71,12 @@ output:\n Building test/src/e2e_vm_tests/test_programs/should_pass/language/intrinsics/dbg\n Compiling li... | true | ||
FuelLabs/sway | 7,620 | comment_to_fix | Fix `Vec` with ZSTs | Having `ref mut` here is problematic from the method's semantic point of view:
- it implies that we are modifying the `val`.
- it also forces callers to pass mutable variables. This is also a breaking change. The fact that `std` compiles at all after this change is because we have a bug in checking the mutability. I've... | b0a91271a06042763b2f62a058141edcfa06cb5f | 69ac773306a480b5013bc9fe53af650da8b54f04 | diff --git a/sway-lib-std/src/raw_ptr.sw b/sway-lib-std/src/raw_ptr.sw
index 8fc2d0cecdd..63aa2bfcdd7 100644
--- a/sway-lib-std/src/raw_ptr.sw
+++ b/sway-lib-std/src/raw_ptr.sw
@@ -163,19 +163,19 @@ impl raw_ptr {
/// }
/// ```
pub fn write<T>(self, val: T) {
- if __is_reference_type::<T>() {
- ... | [
"sway-lib-std/src/raw_ptr.sw"
] | [
{
"comment": "Having `ref mut` here is problematic from the method's semantic point of view:\n- it implies that we are modifying the `val`.\n- it also forces callers to pass mutable variables. This is also a breaking change. The fact that `std` compiles at all after this change is because we have a bug in check... | true | ||
FuelLabs/sway | 7,620 | comment_to_fix | Fix `Vec` with ZSTs | Because `write` is at the bottom of many calls, IMO it makes sense to have it as optimized as possible.
The new implementation requires unnecessary stack allocation for copy types.
IMO we should go here for the best compilation possible, while also making sure that only one branch gets compiled. It might be that this... | b0a91271a06042763b2f62a058141edcfa06cb5f | 69ac773306a480b5013bc9fe53af650da8b54f04 | diff --git a/sway-lib-std/src/raw_ptr.sw b/sway-lib-std/src/raw_ptr.sw
index 8fc2d0cecdd..63aa2bfcdd7 100644
--- a/sway-lib-std/src/raw_ptr.sw
+++ b/sway-lib-std/src/raw_ptr.sw
@@ -163,19 +163,19 @@ impl raw_ptr {
/// }
/// ```
pub fn write<T>(self, val: T) {
- if __is_reference_type::<T>() {
- ... | [
"sway-lib-std/src/raw_ptr.sw"
] | [
{
"comment": "Because `write` is at the bottom of many calls, IMO it makes sense to have it as optimized as possible.\n\nThe new implementation requires unnecessary stack allocation for copy types.\n\nIMO we should go here for the best compilation possible, while also making sure that only one branch gets compi... | true | ||
FuelLabs/sway | 7,620 | comment_to_fix | Fix `Vec` with ZSTs | What about tests for other methods? `Vec` has a large API surface and lot of methods work with memory, like, e.g. resizing the `Vec`.
My thinking here is, if we want to properly support ZSTs in `Vec` we can have a check in every `Vec` method if `T` is zero-sized and provide the trivial implementation. Essentially, `Ve... | b0a91271a06042763b2f62a058141edcfa06cb5f | 69ac773306a480b5013bc9fe53af650da8b54f04 | diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec/src/main.sw
index eb80bc51725..3741f482007 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should... | [
"test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec/src/main.sw"
] | [
{
"comment": "What about tests for other methods? `Vec` has a large API surface and lot of methods work with memory, like, e.g. resizing the `Vec`.\n\nMy thinking here is, if we want to properly support ZSTs in `Vec` we can have a check in every `Vec` method if `T` is zero-sized and provide the trivial implemen... | true | ||
FuelLabs/sway | 7,620 | comment_to_fix | Fix `Vec` with ZSTs | `if __size_of::<T>() == 0 { }` must be the first check because we can have ZST reference types. E.g. if we call `write` with `[u8;0]` or `struct EmptyStruct {}` the `mcp` will still be generated.
A side note, `mcp dest src $zero` is not optimized away. At first look, it looks safe to me to do it (with respect to cl... | b0a91271a06042763b2f62a058141edcfa06cb5f | 69ac773306a480b5013bc9fe53af650da8b54f04 | diff --git a/sway-lib-std/src/raw_ptr.sw b/sway-lib-std/src/raw_ptr.sw
index 8fc2d0cecdd..63aa2bfcdd7 100644
--- a/sway-lib-std/src/raw_ptr.sw
+++ b/sway-lib-std/src/raw_ptr.sw
@@ -163,19 +163,19 @@ impl raw_ptr {
/// }
/// ```
pub fn write<T>(self, val: T) {
- if __is_reference_type::<T>() {
- ... | [
"sway-lib-std/src/raw_ptr.sw"
] | [
{
"comment": "`if __size_of::<T>() == 0 { }` must be the first check because we can have ZST reference types. E.g. if we call `write` with `[u8;0]` or `struct EmptyStruct {}` the `mcp` will still be generated.\n\nA side note, `mcp dest src $zero` is not optimized away. At first look, it looks safe to me to d... | true | ||
FuelLabs/sway | 7,620 | comment_to_fix | Fix `Vec` with ZSTs | > if not, it means that all variants are unit
Strictly speaking, we can still have the internal error situation here, where we don't have the variant type, but not all variants are unit. In that case we should emit ICE as it was the intention of the original code (that didn't respect the case where all variants are un... | b0a91271a06042763b2f62a058141edcfa06cb5f | 69ac773306a480b5013bc9fe53af650da8b54f04 | diff --git a/sway-core/src/ir_generation/function.rs b/sway-core/src/ir_generation/function.rs
index b3089c62be5..812d8fe0a82 100644
--- a/sway-core/src/ir_generation/function.rs
+++ b/sway-core/src/ir_generation/function.rs
@@ -4068,26 +4068,88 @@ impl<'a> FnCompiler<'a> {
// Compile the struct expression.
... | [
"sway-core/src/ir_generation/function.rs"
] | [
{
"comment": "> if not, it means that all variants are unit\n\nStrictly speaking, we can still have the internal error situation here, where we don't have the variant type, but not all variants are unit. In that case we should emit ICE as it was the intention of the original code (that didn't respect the case w... | true | ||
FuelLabs/sway | 7,620 | comment_to_fix | Fix `Vec` with ZSTs | This is safe and it will never clash with a potential `const zero_u64` declared in code, because all user defined constants will be prefixed with the module/parent name.
Still, to emphasize compiler-generation and to conform to SCREAMING_CASE naming convention, proposal is to have `__ZERO_U64` here. | b0a91271a06042763b2f62a058141edcfa06cb5f | 69ac773306a480b5013bc9fe53af650da8b54f04 | diff --git a/sway-core/src/ir_generation/function.rs b/sway-core/src/ir_generation/function.rs
index b3089c62be5..812d8fe0a82 100644
--- a/sway-core/src/ir_generation/function.rs
+++ b/sway-core/src/ir_generation/function.rs
@@ -4068,26 +4068,88 @@ impl<'a> FnCompiler<'a> {
// Compile the struct expression.
... | [
"sway-core/src/ir_generation/function.rs"
] | [
{
"comment": "This is safe and it will never clash with a potential `const zero_u64` declared in code, because all user defined constants will be prefixed with the module/parent name.\n\nStill, to emphasize compiler-generation and to conform to SCREAMING_CASE naming convention, proposal is to have `__ZERO_U64` ... | true | ||
FuelLabs/sway | 7,614 | issue_to_patch | `StorageVec::insert()` does not work with nested storage types
E.g., having:
```Sway
storage {
nested_vec: StorageVec<StorageVec<u64>> = StorageVec {},
}
```
and inserting:
```
storage.nested_vec.insert(0, StorageVec {});
storage.nested_vec.insert(0, StorageVec {});
```
will revert at runtime at the sec... | Implement dynamic storage based `StorageVec` | ## Description
This PR is an additional step in implementing #7560. It implements `StorageVec<V>` for dynamic storage.
Additionally the PR:
- adds comprehensive test coverage for `StorageVec` in the form of in-language tests. Existing SDK harness tests are deleted in favor of new in-language tests. This is align... | 514ccec75cccc818254f09e0c284db2c78b2ec2a | ecc2c92ea28c187e76d47f70d6de0024c884c202 | diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 663f5c6d925..94c9154ad52 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -523,22 +523,39 @@ jobs:
run: forc test --path sway-lib-std --experimental dynamic_storage
- name: Run Std Unit Tests - ['dynamic_storag... | [
".github/workflows/ci.yml",
"justfile",
"sway-lib-std/src/raw_slice.sw",
"sway-lib-std/src/storage/storage_api.sw",
"sway-lib-std/src/storage/storage_bytes.sw",
"sway-lib-std/src/storage/storage_string.sw",
"sway-lib-std/src/storage/storage_vec.sw",
"test/src/e2e_vm_tests/test_programs/should_pass/lan... | [
{
"comment": "### Test verification uses wrong split point for expected sequence\n\n**Low Severity**\n\n<!-- DESCRIPTION START -->\nThe expected sequence construction in `assert_insert_impl` uses `middle_index` (which is an index into the *vector* after front insertion) as a split point into `expected_values`. ... | diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/array/array_repeat/stdout.snap b/test/src/e2e_vm_tests/test_programs/should_pass/language/array/array_repeat/stdout.snap
index 5178a69a0b8..1fcfe35878e 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/array/array_repeat/stdout.sn... | true |
FuelLabs/sway | 7,614 | comment_to_fix | Implement dynamic storage based `StorageVec` | ### Test verification uses wrong split point for expected sequence
**Low Severity**
<!-- DESCRIPTION START -->
The expected sequence construction in `assert_insert_impl` uses `middle_index` (which is an index into the *vector* after front insertion) as a split point into `expected_values`. After the front insert, ori... | 514ccec75cccc818254f09e0c284db2c78b2ec2a | ecc2c92ea28c187e76d47f70d6de0024c884c202 | diff --git a/test/src/in_language_tests/test_programs/storage_vec_insert_contract_tests/src/main.sw b/test/src/in_language_tests/test_programs/storage_vec_insert_contract_tests/src/main.sw
new file mode 100644
index 00000000000..d523111a552
--- /dev/null
+++ b/test/src/in_language_tests/test_programs/storage_vec_insert... | [
"test/src/in_language_tests/test_programs/storage_vec_insert_contract_tests/src/main.sw"
] | [
{
"comment": "### Test verification uses wrong split point for expected sequence\n\n**Low Severity**\n\n<!-- DESCRIPTION START -->\nThe expected sequence construction in `assert_insert_impl` uses `middle_index` (which is an index into the *vector* after front insertion) as a split point into `expected_values`. ... | true | ||
FuelLabs/sway | 7,614 | comment_to_fix | Implement dynamic storage based `StorageVec` | ### Test script runs `forc test` on `test_types` library
**Low Severity**
<!-- DESCRIPTION START -->
The `find` command with `-mindepth 2 -maxdepth 2` matches `test_programs/test_types/Forc.toml` alongside actual test projects. This causes the script to run `forc test` on the `test_types` utility library, which is a ... | 514ccec75cccc818254f09e0c284db2c78b2ec2a | ecc2c92ea28c187e76d47f70d6de0024c884c202 | diff --git a/test/src/in_language_tests/run_in_language_tests.sh b/test/src/in_language_tests/run_in_language_tests.sh
new file mode 100755
index 00000000000..d09239e82e1
--- /dev/null
+++ b/test/src/in_language_tests/run_in_language_tests.sh
@@ -0,0 +1,71 @@
+#!/usr/bin/env bash
+
+# Run `forc test` individually for e... | [
"test/src/in_language_tests/run_in_language_tests.sh"
] | [
{
"comment": "### Test script runs `forc test` on `test_types` library\n\n**Low Severity**\n\n<!-- DESCRIPTION START -->\nThe `find` command with `-mindepth 2 -maxdepth 2` matches `test_programs/test_types/Forc.toml` alongside actual test projects. This causes the script to run `forc test` on the `test_types` u... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.