Implements the Eq trait for Option

sway-lib-std/src/option.sw

@@ -87,6 +87,16 @@ pub enum Option<T> {
 }
 // ANCHOR_END: docs_option
 
+impl<T> core::ops::Eq for Option<T> where T: Eq {
+    fn eq(self, other: Self) -> bool {
+        match (self, other) {
+            (Option::Some(a), Option::Some(b)) => a == b,
+            (Option::None, Option::None) => true,
+            _ => false,
+        }
+    }
+}
+
 // Type implementation
 //
 impl<T> Option<T> {

test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_basic_storage/src/main.sw

@@ -2,7 +2,7 @@ script;
 use basic_storage_abi::{BasicStorage, Quad};
 
 fn main() -> u64 {
-    let addr = abi(BasicStorage, 0xb0d36fd04e733889ce2b24307a00ec871314ed54964404d441aafb376eb01e7d);
+    let addr = abi(BasicStorage, 0xe683b03352239f4b23986cd283948b7dfc22b528ace56859e562dff5a0165dc8);
     let key = 0x0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
     let value = 4242;
 

test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_storage_enum/src/main.sw

@@ -3,7 +3,7 @@ script;
 use storage_enum_abi::*;
 
 fn main() -> u64 {
-    let contract_id = 0x8836ec87c97907ff0f4cf0cf62f852c7f654b8a6bd6845ee2d0203c5dbd029a5;
+    let contract_id = 0xe2f370fb01c8c36a521093494a023ce2d7232398e5e88722164c42ec0303f381;
     let caller = abi(StorageEnum, contract_id);
 
     let res = caller.read_write_enums();

test/src/e2e_vm_tests/test_programs/should_pass/stdlib/option_eq/.gitignore

@@ -0,0 +1,2 @@
+out
+target

test/src/e2e_vm_tests/test_programs/should_pass/stdlib/option_eq/Forc.lock

@@ -0,0 +1,13 @@
+[[package]]
+name = 'core'
+source = 'path+from-root-9E5F9380FAC5610F'
+
+[[package]]
+name = 'option_eq'
+source = 'member'
+dependencies = ['std']
+
+[[package]]
+name = 'std'
+source = 'path+from-root-9E5F9380FAC5610F'
+dependencies = ['core']

test/src/e2e_vm_tests/test_programs/should_pass/stdlib/option_eq/Forc.toml

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

test/src/e2e_vm_tests/test_programs/should_pass/stdlib/option_eq/json_abi_oracle.json

@@ -0,0 +1,25 @@
+{
+  "configurables": [],
+  "functions": [
+    {
+      "attributes": null,
+      "inputs": [],
+      "name": "main",
+      "output": {
+        "name": "",
+        "type": 0,
+        "typeArguments": null
+      }
+    }
+  ],
+  "loggedTypes": [],
+  "messagesTypes": [],
+  "types": [
+    {
+      "components": null,
+      "type": "bool",
+      "typeId": 0,
+      "typeParameters": null
+    }
+  ]
+}

test/src/e2e_vm_tests/test_programs/should_pass/stdlib/option_eq/src/main.sw

@@ -0,0 +1,149 @@
+script;
+
+fn main() -> bool {
+    // Test with u8
+    let u8_option1 = Option::<u8>::Some(10);
+    let u8_option2 = Option::<u8>::Some(10);
+    let u8_option3 = Option::<u8>::Some(20);
+    let u8_none_option: Option<u8> = Option::None;
+
+    // Eq tests
+    assert(u8_option1 == u8_option1);
+    assert(u8_option1 == u8_option2);
+
+    // Neq tests
+    assert(u8_option1 != u8_option3);
+    assert(u8_option1 != u8_none_option);
+
+    // None tests
+    assert(u8_none_option == Option::None);
+    assert(Option::<u8>::None == u8_none_option);
+
+    // Test with u16
+    let u16_option1 = Option::<u16>::Some(10);
+    let u16_option2 = Option::<u16>::Some(10);
+    let u16_option3 = Option::<u16>::Some(20);
+    let u16_none_option: Option<u16> = Option::None;
+
+    // Eq tests
+    assert(u16_option1 == u16_option1);
+    assert(u16_option1 == u16_option2);
+
+    // Neq tests
+    assert(u16_option1 != u16_option3);
+    assert(u16_option1 != u16_none_option);
+
+    // None tests
+    assert(u16_none_option == Option::None);
+    assert(Option::<u16>::None == u16_none_option);
+
+    // Test with u32
+    let u32_option1 = Option::<u32>::Some(10);
+    let u32_option2 = Option::<u32>::Some(10);
+    let u32_option3 = Option::<u32>::Some(20);
+    let u32_none_option: Option<u32> = Option::None;
+
+    // Eq tests
+    assert(u32_option1 == u32_option1);
+    assert(u32_option1 == u32_option2);
+
+    // Neq tests
+    assert(u32_option1 != u32_option3);
+    assert(u32_option1 != u32_none_option);
+
+    // None tests
+    assert(u32_none_option == Option::None);
+    assert(Option::<u32>::None == u32_none_option);
+
+    // Test with u64
+    let u64_option1 = Option::<u64>::Some(10);
+    let u64_option2 = Option::<u64>::Some(10);
+    let u64_option3 = Option::<u64>::Some(20);
+    let u64_none_option: Option<u64> = Option::None;
+
+    // Eq tests
+    assert(u64_option1 == u64_option1);
+    assert(u64_option1 == u64_option2);
+
+    // Neq tests
+    assert(u64_option1 != u64_option3);
+    assert(u64_option1 != u64_none_option);
+
+    // None tests
+    assert(u64_none_option == Option::None);
+    assert(Option::<u64>::None == u64_none_option);
+
+    // Test with u256
+    let u256_option1 = Option::<u256>::Some(10);
+    let u256_option2 = Option::<u256>::Some(10);
+    let u256_option3 = Option::<u256>::Some(20);
+    let u256_none_option: Option<u256> = Option::None;
+
+    // Eq tests
+    assert(u256_option1 == u256_option1);
+    assert(u256_option1 == u256_option2);
+
+    // Neq tests
+    assert(u256_option1 != u256_option3);
+    assert(u256_option1 != u256_none_option);
+
+    // None tests
+    assert(u256_none_option == Option::None);
+    assert(Option::<u256>::None == u256_none_option);
+
+    // Test with str
+    let str_option1 = Option::<str>::Some("fuel");
+    let str_option2 = Option::<str>::Some("fuel");
+    let str_option3 = Option::<str>::Some("sway");
+    let str_none_option: Option<str> = Option::None;
+
+    // Eq tests
+    assert(str_option1 == str_option1);
+    assert(str_option1 == str_option2);
+
+    // Neq tests
+    assert(str_option1 != str_option3);
+    assert(str_option1 != str_none_option);
+
+    // None tests
+    assert(str_none_option == Option::None);
+    assert(Option::<str>::None == str_none_option);
+
+    // Test with bool
+    let bool_option1 = Option::Some(true);
+    let bool_option2 = Option::Some(true);
+    let bool_option3 = Option::Some(false);
+    let bool_none_option: Option<bool> = Option::None;
+
+    // Eq tests
+    assert(bool_option1 == bool_option1);
+    assert(bool_option1 == bool_option2);
+
+    // Neq tests
+    assert(bool_option1 != bool_option3);
+    assert(bool_option1 != bool_none_option);
+
+    // None tests
+    assert(bool_none_option == Option::None);
+    assert(Option::<bool>::None == bool_none_option);
+
+    // Test with b256
+    let b256_option1 = Option::<b256>::Some(0x0000000000000000000000000000000000000000000000000000000000000001);
+    let b256_option2 = Option::<b256>::Some(0x0000000000000000000000000000000000000000000000000000000000000001);
+    let b256_option3 = Option::<b256>::Some(0x0000000000000000000000000000000000000000000000000000000000000002);
+    let b256_none_option: Option<b256> = Option::None;
+
+    // Eq tests
+    assert(b256_option1 == b256_option1);
+    assert(b256_option1 == b256_option2);
+
+    // Neq tests
+    assert(b256_option1 != b256_option3);
+    assert(b256_option1 != b256_none_option);
+
+    // None tests
+    assert(b256_none_option == Option::None);
+    assert(Option::<b256>::None == b256_none_option);
+
+    true
+}

test/src/e2e_vm_tests/test_programs/should_pass/stdlib/option_eq/test.toml

@@ -0,0 +1,3 @@
+category = "run"
+expected_result = { action = "return", value = 1 }
+validate_abi = true