Improve execution time of should_pass E2E tests (#5757)

## Description

This PR improves the execution time of `should_pass` E2E tests by making
~33% of them use a stripped-down version of the `std` library.

This approach brings noticable speed gains as demonstrated in the below
comparison table.
(The tests are executed on my local machine in Rust `release` and Sway
`debug` build. Running them in Sway `release` build brings additional
but small gain.)

| Test filter  | Before (mm:ss) | After (mm:ss) |
| ------------- | ------------- |------------- |
| should_pass/language/ | 14:26 | 04:23 |
| should_pass/language/references | 04:10 | 00:56 |
| should_pass/language/main_args  | 01:10  | 00:12 |
| should_pass/language/match | 00:57 | 00:09 |
| should_pass.*enum | 00:51 | 00:28 |

The improvement approach is based on the following observations:
- most of the time in `should_pass` tests is spent on compiling `std`.
- out of ~480 `should_pass` tests, ~160 use `std` just because of
`assert`.
- in addition, ~10 tests need `Option` and/or `Result`.

Thus, the PR provides two stripped-down versions of the `std`, one
containing only support for `assert`, and another one containing
`assert` and `Option` and `Result`. The compilation time of those two
libraries is negligible compared to the compilation time of the whole
`std`.

This apporach is:
- easy to use and enforce in new tests
- compatible with whichever solution for running tests in parallel we
come up with
- trivial to remove once we implement incremental compilation or caching
of `std` in tests

Therefore, proposal is to use this approach for the time being to
improve the efficiency of our inner loop.

## 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).
- [x] I have added tests that prove my fix is effective or that my
feature works.
- [ ] I have added (or requested a maintainer to add) the necessary
`Breaking*` or `New Feature` labels where relevant.
- [x] I have done my best to ensure that my PR adheres to [the Fuel Labs
Code Review
Standards](https://github.com/FuelLabs/rfcs/blob/master/text/code-standards/external-contributors.md).
- [x] I have requested a review from the relevant team or maintainers.

Author: ironcev

test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-assert/Forc.lock

@@ -0,0 +1,8 @@
+[[package]]
+name = "core"
+source = "path+from-root-5863B5D56901589E"
+
+[[package]]
+name = "std"
+source = "member"
+dependencies = ["core"]

test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-assert/Forc.toml

@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "lib.sw"
+license = "Apache-2.0"
+name = "std"
+
+[dependencies]
+core = { path = "../../../../../sway-lib-core" }

test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-assert/README.md

@@ -0,0 +1,7 @@
+# Reduced Sway Standard Library
+
+This is a reduced version of the Sway Standard Library meant to be used in tests that need only the following `std` functionality:
+- asserts
+- logging
+- revert
+

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

@@ -0,0 +1,124 @@
+//! Functions to assert a given condition.
+library;
+
+use ::logging::log;
+use ::revert::revert;
+use ::error_signals::{FAILED_ASSERT_EQ_SIGNAL, FAILED_ASSERT_NE_SIGNAL, FAILED_ASSERT_SIGNAL};
+
+/// Asserts that the given `condition` will always be `true` during runtime.
+///
+/// # Additional Information
+///
+/// To check for conditions that may not be `true`, use `std::revert::require` instead.
+/// For more information, see the Wiki article on [Assertion](https://en.wikipedia.org/wiki/Assertion_(software_development)#Comparison_with_error_handling).
+///
+/// # Arguments
+///
+/// * `condition`: [bool] - The condition which will be asserted to be `true`.
+///
+/// # Reverts
+///
+/// * Reverts when `condition` is `false`.
+///
+/// # Examples
+///
+/// ```sway
+/// fn foo(a: u64, b: u64) {
+///     assert(a == b);
+///     // if code execution continues, that means a was equal to b
+///     log("a is equal to b");
+/// }
+/// ```
+pub fn assert(condition: bool) {
+    if !condition {
+        revert(FAILED_ASSERT_SIGNAL);
+    }
+}
+
+/// Asserts that the given values `v1` & `v2` will always be equal during runtime.
+///
+/// # Arguments
+///
+/// * `v1`: [T] - The first value to compare.
+/// * `v2`: [T] - The second value to compare.
+///
+/// # Reverts
+///
+/// * Reverts when `v1` != `v2`.
+///
+/// # Examples
+///
+/// ```sway
+/// fn foo(a: u64, b: u64) {
+///     assert_eq(a, b);
+///     // if code execution continues, that means `a` is equal to `b`
+///     log("a is equal to b");
+/// }
+/// ```
+#[cfg(experimental_new_encoding = false)]
+pub fn assert_eq<T>(v1: T, v2: T)
+where
+    T: Eq,
+{
+    if (v1 != v2) {
+        log(v1);
+        log(v2);
+        revert(FAILED_ASSERT_EQ_SIGNAL);
+    }
+}
+
+#[cfg(experimental_new_encoding = true)]
+pub fn assert_eq<T>(v1: T, v2: T)
+where
+    T: Eq + AbiEncode,
+{
+    if (v1 != v2) {
+        log(v1);
+        log(v2);
+        revert(FAILED_ASSERT_EQ_SIGNAL);
+    }
+}
+
+/// Asserts that the given values `v1` & `v2` will never be equal during runtime.
+///
+/// # Arguments
+///
+/// * `v1`: [T] - The first value to compare.
+/// * `v2`: [T] - The second value to compare.
+///
+/// # Reverts
+///
+/// * Reverts when `v1` == `v2`.
+///
+/// # Examples
+///
+/// ```sway
+/// fn foo(a: u64, b: u64) {
+///     assert_ne(a, b);
+///     // if code execution continues, that means `a` is not equal to `b`
+///     log("a is not equal to b");
+/// }
+/// ```
+#[cfg(experimental_new_encoding = false)]
+pub fn assert_ne<T>(v1: T, v2: T)
+where
+    T: Eq,
+{
+    if (v1 == v2) {
+        log(v1);
+        log(v2);
+        revert(FAILED_ASSERT_NE_SIGNAL);
+    }
+}
+
+#[cfg(experimental_new_encoding = true)]
+pub fn assert_ne<T>(v1: T, v2: T)
+where
+    T: Eq + AbiEncode,
+{
+    if (v1 == v2) {
+        log(v1);
+        log(v2);
+        revert(FAILED_ASSERT_NE_SIGNAL);
+    }
+}

test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-assert/src/error_signals.sw

@@ -0,0 +1,37 @@
+//! Values which signify special types of errors when passed to `std::revert::revert`.
+library;
+
+/// A revert with this value signals that it was caused by a failing call to `std::revert::require`.
+///
+/// # Additional Information
+///
+/// The value is: 18446744073709486080
+pub const FAILED_REQUIRE_SIGNAL = 0xffff_ffff_ffff_0000;
+
+/// A revert with this value signals that it was caused by a failing call to `std::asset::transfer_to_address`.
+///
+/// # Additional Information
+///
+/// The value is: 18446744073709486081
+pub const FAILED_TRANSFER_TO_ADDRESS_SIGNAL = 0xffff_ffff_ffff_0001;
+
+/// A revert with this value signals that it was caused by a failing call to `std::assert::assert_eq`.
+///
+/// # Additional Information
+///
+/// The value is: 18446744073709486083
+pub const FAILED_ASSERT_EQ_SIGNAL = 0xffff_ffff_ffff_0003;
+
+/// A revert with this value signals that it was caused by a failing call to `std::assert::assert`.
+///
+/// # Additional Information
+///
+/// The value is: 18446744073709486084
+pub const FAILED_ASSERT_SIGNAL = 0xffff_ffff_ffff_0004;
+
+/// A revert with this value signals that it was caused by a failing call to `std::assert::assert_ne`.
+///
+/// # Additional Information
+///
+/// The value is: 18446744073709486085
+pub const FAILED_ASSERT_NE_SIGNAL = 0xffff_ffff_ffff_0005;

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

@@ -0,0 +1,9 @@
+library;
+
+pub mod error_signals;
+pub mod logging;
+pub mod revert;
+pub mod assert;
+pub mod prelude;
+
+use core::*;

test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-assert/src/logging.sw

@@ -0,0 +1,33 @@
+//! Allows logging of arbitrary stack types, emitted as either `Log` or `Logd` receipts.
+library;
+
+/// Log any stack type.
+///
+/// # Additional Information
+///
+/// If the type is a reference type, `log` is used.
+/// Otherwise `logd` is used.'
+///
+/// # Arguments
+///
+/// * `value`: [T] - The value to log.
+///
+/// # Examples
+///
+/// ```sway
+/// fn foo() {
+///     log("Fuel is blazingly fast");
+/// }
+/// ```
+#[cfg(experimental_new_encoding = false)]
+pub fn log<T>(value: T) {
+    __log::<T>(value);
+}
+
+#[cfg(experimental_new_encoding = true)]
+pub fn log<T>(value: T)
+where
+    T: AbiEncode,
+{
+    __log::<T>(value);
+}

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

@@ -0,0 +1,11 @@
+//! Defines the Sway standard library prelude.
+//! The prelude consists of implicitly available items,
+//! for which `use` is not required.
+library;
+
+// Error handling
+use ::assert::{assert, assert_eq, assert_ne};
+use ::revert::{require, revert};
+
+// Logging
+use ::logging::log;

test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-assert/src/revert.sw

@@ -0,0 +1,73 @@
+//! Functions to panic or revert with a given error code.
+library;
+
+use ::logging::log;
+use ::error_signals::FAILED_REQUIRE_SIGNAL;
+
+/// Will either panic or revert with a given number depending on the context.
+///
+/// # Additional Information
+///
+/// If used in a predicate, it will panic.
+/// If used in a contract, it will revert.
+///
+/// # Arguments
+///
+/// * `code`: [u64] - The code with which to revert the program.
+///
+/// # Reverts
+///
+/// * Reverts unconditionally.
+///
+/// # Examples
+///
+/// ```sway
+/// fn foo(should_revert: bool) {
+///     match should_revert {
+///         true => revert(0),
+///         false => {},
+///     }
+/// }
+/// ```
+pub fn revert(code: u64) -> ! {
+    __revert(code)
+}
+
+/// Checks if the given `condition` is `true` and if not, logs `value` and reverts.
+///
+/// # Arguments
+///
+/// * `condition`: [bool] - The condition upon which to decide whether to revert or not.
+/// * `value`: [T] - The value which will be logged in case `condition` is `false`.
+///
+/// # Reverts
+///
+/// * Reverts when `condition` is `false`.
+///
+/// # Examples
+///
+/// ```sway
+/// fn foo(a: u64, b: u64) {
+///     require(a == b, "a was not equal to b");
+///     // If the condition was true, code execution will continue
+///     log("The require function did not revert");
+/// }
+/// ```
+#[cfg(experimental_new_encoding = false)]
+pub fn require<T>(condition: bool, value: T) {
+    if !condition {
+        log(value);
+        revert(FAILED_REQUIRE_SIGNAL)
+    }
+}
+
+#[cfg(experimental_new_encoding = true)]
+pub fn require<T>(condition: bool, value: T)
+where
+    T: AbiEncode,
+{
+    if !condition {
+        log(value);
+        revert(FAILED_REQUIRE_SIGNAL)
+    }
+}

test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-option-result/Forc.lock

@@ -0,0 +1,8 @@
+[[package]]
+name = "core"
+source = "path+from-root-5863B5D56901589E"
+
+[[package]]
+name = "std"
+source = "member"
+dependencies = ["core"]

test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-option-result/Forc.toml

@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "lib.sw"
+license = "Apache-2.0"
+name = "std"
+
+[dependencies]
+core = { path = "../../../../../sway-lib-core" }

test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-option-result/README.md

@@ -0,0 +1,8 @@
+# Reduced Sway Standard Library
+
+This is a reduced version of the Sway Standard Library meant to be used in tests that need only the following `std` functionality:
+- asserts
+- logging
+- revert
+- `Option` type
+- `Result` type