Fix Result type generation for user-defined error enums named "Error"

tests/add_u64/src/lib.rs

@@ -1,21 +1,39 @@
 #![no_std]
-use soroban_sdk::{contract, contractimpl};
+use soroban_sdk::{contract, contracterror, contractimpl};
 
 #[contract]
 pub struct Contract;
 
+#[contracterror]
+#[derive(Debug, PartialEq)]
+pub enum Error {
+    Overflow = 1,
+}
+
+#[contracterror]
+#[derive(Debug, PartialEq)]
+pub enum MyError {
+    Overflow = 1,
+}
+
 #[contractimpl]
 impl Contract {
     pub fn add(a: u64, b: u64) -> u64 {
         a + b
     }
+    pub fn safe_add(a: u64, b: u64) -> Result<u64, Error> {
+        a.checked_add(b).ok_or(Error::Overflow)
+    }
+    pub fn safe_add_two(a: u64, b: u64) -> Result<u64, MyError> {
+        a.checked_add(b).ok_or(MyError::Overflow)
+    }
 }
 
 #[cfg(test)]
 mod test {
     use soroban_sdk::Env;
 
-    use crate::{Contract, ContractClient};
+    use crate::{Contract, ContractClient, Error};
 
     #[test]
     fn test_add() {
@@ -28,4 +46,15 @@ mod test {
         let z = client.add(&x, &y);
         assert!(z == 22);
     }
+    #[test]
+    fn test_safe_add() {
+        let e = Env::default();
+        let contract_id = e.register(Contract, ());
+        let client = ContractClient::new(&e, &contract_id);
+
+        let x = u64::MAX;
+        let y = 1;
+        let z = client.try_safe_add(&x, &y);
+        assert_eq!(z, Err(Ok(Error::Overflow)));
+    }
 }

tests/add_u64/test_snapshots/test/test_safe_add.1.json

@@ -0,0 +1,61 @@
+{
+  "generators": {
+    "address": 1,
+    "nonce": 0,
+    "mux_id": 0
+  },
+  "auth": [
+    [],
+    []
+  ],
+  "ledger": {
+    "protocol_version": 26,
+    "sequence_number": 0,
+    "timestamp": 0,
+    "network_id": "0000000000000000000000000000000000000000000000000000000000000000",
+    "base_reserve": 0,
+    "min_persistent_entry_ttl": 4096,
+    "min_temp_entry_ttl": 16,
+    "max_entry_ttl": 6312000,
+    "ledger_entries": [
+      {
+        "entry": {
+          "last_modified_ledger_seq": 0,
+          "data": {
+            "contract_data": {
+              "ext": "v0",
+              "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM",
+              "key": "ledger_key_contract_instance",
+              "durability": "persistent",
+              "val": {
+                "contract_instance": {
+                  "executable": {
+                    "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+                  },
+                  "storage": null
+                }
+              }
+            }
+          },
+          "ext": "v0"
+        },
+        "live_until": 4095
+      },
+      {
+        "entry": {
+          "last_modified_ledger_seq": 0,
+          "data": {
+            "contract_code": {
+              "ext": "v0",
+              "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+              "code": ""
+            }
+          },
+          "ext": "v0"
+        },
+        "live_until": 4095
+      }
+    ]
+  },
+  "events": []
+}

tests/import_contract/src/lib.rs

@@ -1,10 +1,17 @@
 #![no_std]
-use soroban_sdk::{contract, contractimpl, Address, Env};
+use soroban_sdk::{contract, contracterror, contractimpl, Address, Env};
 
 mod addcontract {
     soroban_sdk::contractimport!(file = "../../target/wasm32v1-none/release/test_add_u64.wasm");
 }
 
+#[contracterror]
+#[derive(Debug, PartialEq)]
+pub enum Error {
+    Abort = 0,
+    Overflow = 1,
+}
+
 #[contract]
 pub struct Contract;
 
@@ -13,13 +20,27 @@ impl Contract {
     pub fn add_with(env: Env, contract_id: Address, x: u64, y: u64) -> u64 {
         addcontract::Client::new(&env, &contract_id).add(&x, &y)
     }
+    pub fn safe_add_with(env: Env, contract_id: Address, x: u64, y: u64) -> Result<u64, Error> {
+        match addcontract::Client::new(&env, &contract_id).try_safe_add(&x, &y) {
+            Ok(Ok(i)) => Ok(i),
+            Err(Ok(addcontract::Error::Overflow)) => Err(Error::Overflow),
+            _ => Err(Error::Abort),
+        }
+    }
+    pub fn safe_add_with_two(env: Env, contract_id: Address, x: u64, y: u64) -> Result<u64, Error> {
+        match addcontract::Client::new(&env, &contract_id).try_safe_add_two(&x, &y) {
+            Ok(Ok(i)) => Ok(i),
+            Err(Ok(addcontract::MyError::Overflow)) => Err(Error::Overflow),
+            _ => Err(Error::Abort),
+        }
+    }
 }
 
 #[cfg(test)]
 mod test {
     use soroban_sdk::Env;
 
-    use crate::{addcontract, Contract, ContractClient};
+    use crate::{addcontract, Contract, ContractClient, Error};
 
     #[test]
     fn test_add() {
@@ -34,4 +55,20 @@ mod test {
         let z = client.add_with(&add_contract_id, &x, &y);
         assert!(z == 22);
     }
+
+    #[test]
+    fn test_safe_add() {
+        let e = Env::default();
+        let add_contract_id = e.register(addcontract::WASM, ());
+
+        let contract_id = e.register(Contract, ());
+        let client = ContractClient::new(&e, &contract_id);
+
+        let x = u64::MAX;
+        let y = 1;
+        let z = client.try_safe_add_with(&add_contract_id, &x, &y);
+        assert_eq!(z, Err(Ok(Error::Overflow)));
+        let z = client.try_safe_add_with_two(&add_contract_id, &x, &y);
+        assert_eq!(z, Err(Ok(Error::Overflow)));
+    }
 }