Use thiserror instead of snafu in std

Author: webmaster128

CHANGELOG.md

@@ -7,6 +7,11 @@
 - Remove the previously deprecated `StdError::Unauthorized`. Contract specific
   errors should be implemented using custom error types now (see
   [migration guide](./MIGRATING.md) 0.10 -> 0.11).
+- Use dependency `thiserror` instead of `snafu` to implement `StdError`. Along
+  with this change, the `backtraces` feature now requires Rust nightly.
+- Rename `StdError::ParseErr::source` to `StdError::ParseErr::source_type` and
+  `StdError::SerializeErr::target` to `StdError::SerializeErr::target_type` to
+  work around speacial treatment of the field name `source` in thiserror.
 
 **cosmwasm-vm**
 

Cargo.lock

@@ -4,6 +4,25 @@ This guide explains what is needed to upgrade contracts when migrating over
 major releases of `cosmwasm`. Note that you can also view the
 [complete CHANGELOG](./CHANGELOG.md) to understand the differences.
 
+## 0.11 -> 0.12
+
+- In your contract's `.cargo/config` remove `--features backtraces`, which is
+  now available in Rust nightly only:
+
+  ```diff
+  @@ -1,6 +1,6 @@
+   [alias]
+   wasm = "build --release --target wasm32-unknown-unknown"
+   wasm-debug = "build --target wasm32-unknown-unknown"
+  -unit-test = "test --lib --features backtraces"
+  +unit-test = "test --lib"
+   integration-test = "test --test integration"
+   schema = "run --example schema"
+  ```
+
+  In order to use backtraces for debugging, run
+  `RUST_BACKTRACE=1 cargo +nightly unit-test --features backtraces`.
+
 ## 0.10 -> 0.11
 
 - Contracts now support any custom error type `E: ToString + From<StdError>`.

MIGRATING.md

@@ -1,6 +1,6 @@
 [alias]
 wasm = "build --release --target wasm32-unknown-unknown"
 wasm-debug = "build --target wasm32-unknown-unknown"
-unit-test = "test --lib --features backtraces"
+unit-test = "test --lib"
 integration-test = "test --test integration"
 schema = "run --example schema"

contracts/burner/.cargo/config

@@ -1,6 +1,6 @@
 [alias]
 wasm = "build --release --target wasm32-unknown-unknown"
 wasm-debug = "build --target wasm32-unknown-unknown"
-unit-test = "test --lib --features backtraces"
+unit-test = "test --lib"
 integration-test = "test --test integration"
 schema = "run --example schema"

contracts/burner/Cargo.lock

@@ -1,6 +1,6 @@
 [alias]
 wasm = "build --release --target wasm32-unknown-unknown"
 wasm-debug = "build --target wasm32-unknown-unknown"
-unit-test = "test --lib --features backtraces"
+unit-test = "test --lib"
 integration-test = "test --test integration"
 schema = "run --example schema"

contracts/hackatom/.cargo/config

@@ -1,6 +1,6 @@
 [alias]
 wasm = "build --release --target wasm32-unknown-unknown"
 wasm-debug = "build --target wasm32-unknown-unknown"
-unit-test = "test --lib --features backtraces"
+unit-test = "test --lib"
 integration-test = "test --test integration"
 schema = "run --example schema"

contracts/hackatom/Cargo.lock

@@ -1,6 +1,6 @@
 [alias]
 wasm = "build --release --target wasm32-unknown-unknown"
 wasm-debug = "build --target wasm32-unknown-unknown"
-unit-test = "test --lib --features backtraces"
+unit-test = "test --lib"
 integration-test = "test --test integration"
 schema = "run --example schema"

contracts/queue/.cargo/config

@@ -1,5 +1,5 @@
 [alias]
 wasm = "build --release --target wasm32-unknown-unknown"
 wasm-debug = "build --target wasm32-unknown-unknown"
-unit-test = "test --lib --features backtraces"
+unit-test = "test --lib"
 schema = "run --example schema"

contracts/queue/Cargo.lock

@@ -25,14 +25,15 @@ iterator = []
 staking = []
 # backtraces provides much better context at runtime errors (in non-wasm code)
 # at the cost of a bit of code size and performance.
-backtraces = ["snafu/backtraces"]
+# This feature requires Rust nightly because it depends on the unstable backtrace feature.
+backtraces = []
 
 [dependencies]
 base64 = "0.11.0"
 serde-json-wasm = { version = "0.2.1" }
 schemars = "0.7"
 serde = { version = "1.0.103", default-features = false, features = ["derive", "alloc"] }
-snafu = { version = "0.6.6" }
+thiserror = "1.0"
 
 [dev-dependencies]
 cosmwasm-schema = { path = "../schema" }

contracts/reflect/.cargo/config

@@ -1,4 +1,6 @@
-use snafu::Snafu;
+#[cfg(feature = "backtraces")]
+use std::backtrace::Backtrace;
+use thiserror::Error;
 
 /// Structured error type for init, handle and query.
 ///
@@ -15,99 +17,117 @@ use snafu::Snafu;
 /// Checklist for adding a new error:
 /// - Add enum case
 /// - Add creator function in std_error_helpers.rs
-#[derive(Debug, Snafu)]
-#[non_exhaustive]
+#[derive(Error, Debug)]
 pub enum StdError {
     /// Whenever there is no specific error type available
-    #[snafu(display("Generic error: {}", msg))]
+    #[error("Generic error: {msg}")]
     GenericErr {
         msg: String,
-        backtrace: Option<snafu::Backtrace>,
+        #[cfg(feature = "backtraces")]
+        backtrace: Backtrace,
     },
-    #[snafu(display("Invalid Base64 string: {}", msg))]
+    #[error("Invalid Base64 string: {msg}")]
     InvalidBase64 {
         msg: String,
-        backtrace: Option<snafu::Backtrace>,
+        #[cfg(feature = "backtraces")]
+        backtrace: Backtrace,
     },
     /// Whenever UTF-8 bytes cannot be decoded into a unicode string, e.g. in String::from_utf8 or str::from_utf8.
-    #[snafu(display("Cannot decode UTF8 bytes into string: {}", msg))]
+    #[error("Cannot decode UTF8 bytes into string: {msg}")]
     InvalidUtf8 {
         msg: String,
-        backtrace: Option<snafu::Backtrace>,
+        #[cfg(feature = "backtraces")]
+        backtrace: Backtrace,
     },
-    #[snafu(display("{} not found", kind))]
+    #[error("{kind} not found")]
     NotFound {
         kind: String,
-        backtrace: Option<snafu::Backtrace>,
+        #[cfg(feature = "backtraces")]
+        backtrace: Backtrace,
     },
-    #[snafu(display("Error parsing into type {}: {}", target, msg))]
+    #[error("Error parsing into type {target_type}: {msg}")]
     ParseErr {
         /// the target type that was attempted
-        target: String,
+        target_type: String,
         msg: String,
-        backtrace: Option<snafu::Backtrace>,
+        #[cfg(feature = "backtraces")]
+        backtrace: Backtrace,
     },
-    #[snafu(display("Error serializing type {}: {}", source, msg))]
+    #[error("Error serializing type {source_type}: {msg}")]
     SerializeErr {
         /// the source type that was attempted
-        #[snafu(source(false))]
-        source: String,
+        source_type: String,
         msg: String,
-        backtrace: Option<snafu::Backtrace>,
+        #[cfg(feature = "backtraces")]
+        backtrace: Backtrace,
     },
-    #[snafu(display("Cannot subtract {} from {}", subtrahend, minuend))]
+    #[error("Cannot subtract {subtrahend} from {minuend}")]
     Underflow {
         minuend: String,
         subtrahend: String,
-        backtrace: Option<snafu::Backtrace>,
+        #[cfg(feature = "backtraces")]
+        backtrace: Backtrace,
     },
 }
 
 impl StdError {
     pub fn generic_err<S: Into<String>>(msg: S) -> Self {
-        GenericErr { msg: msg.into() }.build()
+        StdError::GenericErr {
+            msg: msg.into(),
+            #[cfg(feature = "backtraces")]
+            backtrace: Backtrace::capture(),
+        }
     }
 
     pub fn invalid_base64<S: ToString>(msg: S) -> Self {
-        InvalidBase64 {
+        StdError::InvalidBase64 {
             msg: msg.to_string(),
+            #[cfg(feature = "backtraces")]
+            backtrace: Backtrace::capture(),
         }
-        .build()
     }
 
     pub fn invalid_utf8<S: ToString>(msg: S) -> Self {
-        InvalidUtf8 {
+        StdError::InvalidUtf8 {
             msg: msg.to_string(),
+            #[cfg(feature = "backtraces")]
+            backtrace: Backtrace::capture(),
         }
-        .build()
     }
 
     pub fn not_found<S: Into<String>>(kind: S) -> Self {
-        NotFound { kind: kind.into() }.build()
+        StdError::NotFound {
+            kind: kind.into(),
+            #[cfg(feature = "backtraces")]
+            backtrace: Backtrace::capture(),
+        }
     }
 
     pub fn parse_err<T: Into<String>, M: ToString>(target: T, msg: M) -> Self {
-        ParseErr {
-            target: target.into(),
+        StdError::ParseErr {
+            target_type: target.into(),
             msg: msg.to_string(),
+            #[cfg(feature = "backtraces")]
+            backtrace: Backtrace::capture(),
         }
-        .build()
     }
 
     pub fn serialize_err<S: Into<String>, M: ToString>(source: S, msg: M) -> Self {
-        SerializeErr {
-            source: source.into(),
+        StdError::SerializeErr {
+            source_type: source.into(),
             msg: msg.to_string(),
+            #[cfg(feature = "backtraces")]
+            backtrace: Backtrace::capture(),
         }
-        .build()
     }
 
     pub fn underflow<U: ToString>(minuend: U, subtrahend: U) -> Self {
-        Underflow {
+        StdError::Underflow {
             minuend: minuend.to_string(),
             subtrahend: subtrahend.to_string(),
+            #[cfg(feature = "backtraces")]
+            backtrace: Backtrace::capture(),
         }
-        .build()
     }
 }
 
@@ -206,8 +226,10 @@ mod test {
     fn parse_err_works() {
         let error = StdError::parse_err("Book", "Missing field: title");
         match error {
-            StdError::ParseErr { target, msg, .. } => {
-                assert_eq!(target, "Book");
+            StdError::ParseErr {
+                target_type, msg, ..
+            } => {
+                assert_eq!(target_type, "Book");
                 assert_eq!(msg, "Missing field: title");
             }
             _ => panic!("expect different error"),
@@ -218,8 +240,10 @@ mod test {
     fn serialize_err_works() {
         let error = StdError::serialize_err("Book", "Content too long");
         match error {
-            StdError::SerializeErr { source, msg, .. } => {
-                assert_eq!(source, "Book");
+            StdError::SerializeErr {
+                source_type, msg, ..
+            } => {
+                assert_eq!(source_type, "Book");
                 assert_eq!(msg, "Content too long");
             }
             _ => panic!("expect different error"),
@@ -264,7 +288,7 @@ mod test {
         let embedded = format!("Debug message: {:?}", error);
         assert_eq!(
             embedded,
-            r#"Debug message: Underflow { minuend: "3", subtrahend: "5", backtrace: None }"#
+            r#"Debug message: Underflow { minuend: "3", subtrahend: "5" }"#
         );
     }
 

contracts/reflect/Cargo.lock

@@ -1,3 +1,5 @@
+#![cfg_attr(feature = "backtraces", feature(backtrace))]
+
 // Exposed on all platforms
 
 mod addresses;