feat(gstd): get panic message without panic_info_message

Cargo.toml

@@ -200,7 +200,7 @@ gcore = { path = "gcore" }
 gcli = { path = "gcli" }
 gclient = { path = "gclient" }
 gsdk = { path = "gsdk" }
-gstd = { path = "gstd", features = [ "nightly" ] }
+gstd = { path = "gstd", features = ["nightly"] }
 gsys = { path = "gsys" }
 gtest = { path = "gtest" }
 gmeta = { path = "gmeta" }

gstd/Cargo.toml

@@ -6,6 +6,7 @@ edition.workspace = true
 license.workspace = true
 
 [dependencies]
+arrayvec = { version = "0.7.4", default-features = false, optional = true }
 document-features = { version = "0.2.7", optional = true }
 galloc.workspace = true
 gcore = { workspace = true, features = ["codec"] }
@@ -16,17 +17,22 @@ bs58 = { workspace = true, features = ["alloc"] }
 hex = { workspace = true, features = ["alloc"] }
 parity-scale-codec = { workspace = true, features = ["derive"] }
 primitive-types = { workspace = true, features = ["scale-info"] }
+rustversion = { version = "1.0", optional = true }
 scale-info = { workspace = true, features = ["derive"] }
 futures = { workspace = true, features = ["alloc"] }
 
 static_assertions.workspace = true
 
+[dev-dependencies]
+rustversion = "1.0"
+
 [features]
 #! ## Default features
 
-default = ["panic-handler"]
-## When enabled, a panic handler is provided by this crate.
-panic-handler = []
+default = ["common-handlers"]
+## When enabled, a panic handler and an OOM error handler are provided by this crate.
+## Note that the OOM error handler is provided when "nightly" feature is enabled.
+common-handlers = []
 
 #! ## Nightly features
 
@@ -44,7 +50,7 @@ oom-handler = []
 
 ## Enables debug logging; this heavily impacts gas cost 
 ## and is therefore disabled by default.
-debug = ["galloc/debug", "gcore/debug"]
+debug = ["galloc/debug", "gcore/debug", "arrayvec", "rustversion"]
 
 #! [rust-66745]: https://github.com/rust-lang/rust/issues/66745
 #! [rust-51540]: https://github.com/rust-lang/rust/issues/51540

gstd/src/common/handlers.rs

@@ -25,50 +25,209 @@
 //! debug and non-debug mode, for programs built in `wasm32` architecture.
 //! For `debug` mode it provides more extensive logging.
 
+#[cfg(target_arch = "wasm32")]
 #[cfg(feature = "oom-handler")]
 #[alloc_error_handler]
 pub fn oom(_: core::alloc::Layout) -> ! {
     crate::ext::oom_panic()
 }
 
-#[cfg(feature = "panic-handler")]
-mod panic_handler {
-    use crate::ext;
-    use core::panic::PanicInfo;
+/// We currently support 2 panic handler modes:
+/// - non-debug: it prints `no info`
+/// - debug: it prints `'{message}', {location}`
+///   - In nightly Rust, we use `#![feature(panic_info_message)]` and the
+///     [`write!`] macro.
+///   - In stable Rust, we need to modify the default panic handler message
+///     format.
+///
+/// Default panic handler message format (according to <https://github.com/rust-lang/rust/pull/112849>):
+/// - Rust  <1.73: `panicked at '{message}', {location}`
+/// - Rust >=1.73: `panicked at {location}:\n{message}`
+///
+/// We parse the output of `impl Display for PanicInfo<'_>` and
+/// then convert it to custom format: `'{message}', {location}`.
+///
+/// Here is a test to verify that the default panic handler message format
+/// has not changed:
+/// ```
+/// use std::panic::{self, PanicInfo};
+///
+/// const MESSAGE: &str = "message";
+///
+/// #[rustversion::before(1.73)]
+/// fn expected_format(panic_info: &PanicInfo) -> String {
+///     let location = panic_info.location().unwrap();
+///     format!("panicked at '{MESSAGE}', {location}")
+/// }
+///
+/// #[rustversion::since(1.73)]
+/// fn expected_format(panic_info: &PanicInfo) -> String {
+///     let location = panic_info.location().unwrap();
+///     format!("panicked at {location}:\n{MESSAGE}")
+/// }
+///
+/// panic::set_hook(Box::new(|panic_info| {
+///     assert_eq!(panic_info.to_string(), expected_format(panic_info));
+/// }));
+///
+/// let result = panic::catch_unwind(|| {
+///     panic!("{MESSAGE}");
+/// });
+/// assert!(result.is_err());
+/// ```
+pub mod panic_handler {
+    #[cfg(target_arch = "wasm32")]
+    mod internal {
+        use crate::ext;
+        use core::panic::PanicInfo;
 
-    #[cfg(not(feature = "debug"))]
-    #[panic_handler]
-    pub fn panic(_: &PanicInfo) -> ! {
-        ext::panic("no info")
-    }
+        /// Panic handler when debug feature is disabled.
+        #[cfg(not(feature = "debug"))]
+        #[panic_handler]
+        pub fn panic(_: &PanicInfo) -> ! {
+            ext::panic("no info")
+        }
 
-    #[cfg(feature = "debug")]
-    #[panic_handler]
-    pub fn panic(panic_info: &PanicInfo) -> ! {
-        use crate::prelude::format;
-        #[cfg(not(feature = "panic-messages"))]
-        let message = None::<&core::fmt::Arguments<'_>>;
+        #[cfg(feature = "debug")]
+        mod constants {
+            /// Max amount of bytes allowed to be thrown as string explanation
+            /// of the error.
+            pub const TRIMMED_MAX_LEN: usize = 1024; //TODO: do not duplicate `gear_core::str::TRIMMED_MAX_LEN`
+            /// This prefix is used to print debug message:
+            /// `debug!("panic occurred: {msg}")`.
+            pub const PANIC_OCCURRED: &str = "panic occurred: ";
+            /// This prefix is used by `impl Display for PanicInfo<'_>`.
+            #[cfg(not(feature = "panic-messages"))]
+            pub const PANICKED_AT: &str = "panicked at ";
+        }
+
+        #[cfg(feature = "debug")]
+        use constants::*;
+
+        /// Panic handler for nightly Rust.
+        #[cfg(feature = "debug")]
         #[cfg(feature = "panic-messages")]
-        let message = panic_info.message();
-
-        let msg = match (message, panic_info.location()) {
-            (Some(msg), Some(loc)) => format!(
-                "'{:?}', {}:{}:{}",
-                msg,
-                loc.file(),
-                loc.line(),
-                loc.column()
-            ),
-            (Some(msg), None) => format!("'{msg:?}'"),
-            (None, Some(loc)) => {
-                format!("{}:{}:{}", loc.file(), loc.line(), loc.column())
+        #[panic_handler]
+        pub fn panic(panic_info: &PanicInfo) -> ! {
+            use crate::prelude::{fmt::Write, mem::MaybeUninit, str};
+            use arrayvec::ArrayString;
+
+            let option = panic_info.message().zip(panic_info.location());
+            let (message, location) = unsafe { option.unwrap_unchecked() };
+
+            fn itoa_u32(buffer: &mut [MaybeUninit<u8>; 10], mut n: u32) -> &str {
+                let mut idx = buffer.len();
+                loop {
+                    idx -= 1;
+                    unsafe { buffer.get_unchecked_mut(idx) }.write((n % 10) as u8 + b'0');
+                    n /= 10;
+                    if n == 0 {
+                        break;
+                    }
+                }
+                unsafe {
+                    str::from_utf8_unchecked(
+                        &*(buffer.get_unchecked(idx..) as *const [_] as *const _),
+                    )
+                }
+            }
+
+            let mut debug_msg = ArrayString::<{ PANIC_OCCURRED.len() + TRIMMED_MAX_LEN }>::new();
+            let mut buffer = unsafe { MaybeUninit::uninit().assume_init() };
+
+            let _ = debug_msg.try_push_str(PANIC_OCCURRED);
+            let _ = debug_msg.try_push_str("'");
+            let _ = write!(&mut debug_msg, "{message}");
+            let _ = debug_msg.try_push_str("', ");
+            let _ = debug_msg.try_push_str(location.file());
+            let _ = debug_msg.try_push_str(":");
+            let _ = debug_msg.try_push_str(itoa_u32(&mut buffer, location.line()));
+            let _ = debug_msg.try_push_str(":");
+            let _ = debug_msg.try_push_str(itoa_u32(&mut buffer, location.column()));
+
+            let _ = ext::debug(&debug_msg);
+
+            let msg = unsafe { debug_msg.get_unchecked(PANIC_OCCURRED.len()..) };
+            ext::panic(&msg)
+        }
+
+        /// Panic handler for stable Rust <1.73.
+        #[rustversion::before(1.73)]
+        #[cfg(feature = "debug")]
+        #[cfg(not(feature = "panic-messages"))]
+        #[panic_handler]
+        pub fn panic(panic_info: &PanicInfo) -> ! {
+            use crate::prelude::fmt::Write;
+            use arrayvec::ArrayString;
+
+            static_assertions::const_assert!(PANICKED_AT.len() == (PANIC_OCCURRED.len() - 4));
+
+            let mut debug_msg = ArrayString::<{ PANIC_OCCURRED.len() + TRIMMED_MAX_LEN }>::new();
+
+            let _ = debug_msg.try_push_str(&PANIC_OCCURRED[..4]);
+            let _ = write!(&mut debug_msg, "{panic_info}");
+
+            let src = (&PANIC_OCCURRED[4..]).as_bytes();
+            let dest = unsafe {
+                debug_msg
+                    .as_bytes_mut()
+                    .get_unchecked_mut(4..PANIC_OCCURRED.len())
+            };
+            dest.copy_from_slice(src);
+
+            let _ = ext::debug(&debug_msg);
+
+            let msg = unsafe { debug_msg.get_unchecked(PANIC_OCCURRED.len()..) };
+            ext::panic(&msg)
+        }
+
+        /// Panic handler for stable Rust >=1.73.
+        #[rustversion::since(1.73)]
+        #[cfg(feature = "debug")]
+        #[cfg(not(feature = "panic-messages"))]
+        #[panic_handler]
+        pub fn panic(panic_info: &PanicInfo) -> ! {
+            use crate::prelude::{fmt::Write, str};
+            use arrayvec::ArrayString;
+
+            let mut default_panic_msg =
+                ArrayString::<{ PANICKED_AT.len() + TRIMMED_MAX_LEN }>::new();
+            let _ = write!(&mut default_panic_msg, "{panic_info}");
+
+            fn parse_panic_msg(msg: &str) -> Option<(&str, &str)> {
+                const NEEDLE: [u8; 2] = *b":\n";
+
+                let msg_bytes = msg.as_bytes();
+                msg_bytes
+                    .windows(NEEDLE.len())
+                    .position(|window| NEEDLE.eq(window))
+                    .map(|pos| unsafe {
+                        (
+                            str::from_utf8_unchecked(
+                                msg_bytes.get_unchecked(PANICKED_AT.len()..pos),
+                            ),
+                            str::from_utf8_unchecked(
+                                msg_bytes.get_unchecked((pos + NEEDLE.len())..),
+                            ),
+                        )
+                    })
             }
-            _ => ext::panic("no info"),
-        };
 
-        crate::debug!("panic occurred: {msg}");
-        ext::panic(&msg)
+            let option = parse_panic_msg(&default_panic_msg);
+            let (location, message) = unsafe { option.unwrap_unchecked() };
+
+            let mut debug_msg = ArrayString::<{ PANIC_OCCURRED.len() + TRIMMED_MAX_LEN }>::new();
+
+            let _ = debug_msg.try_push_str(PANIC_OCCURRED);
+            let _ = debug_msg.try_push_str("'");
+            let _ = debug_msg.try_push_str(message);
+            let _ = debug_msg.try_push_str("', ");
+            let _ = debug_msg.try_push_str(location);
+
+            let _ = ext::debug(&debug_msg);
+
+            let msg = unsafe { debug_msg.get_unchecked(PANIC_OCCURRED.len()..) };
+            ext::panic(&msg)
+        }
     }
 }
-#[cfg(feature = "panic-handler")]
-pub use panic_handler::*;

gstd/src/common/mod.rs

@@ -19,6 +19,6 @@
 //! Common modules for each Gear smart contract.
 
 pub mod errors;
-#[cfg(target_arch = "wasm32")]
+#[cfg(feature = "common-handlers")]
 mod handlers;
 pub mod primitives;

gstd/src/lib.rs

@@ -129,7 +129,7 @@
 #![no_std]
 #![warn(missing_docs)]
 #![cfg_attr(
-    all(target_arch = "wasm32", feature = "panic-messages",),
+    all(target_arch = "wasm32", feature = "panic-messages"),
     feature(panic_info_message)
 )]
 #![cfg_attr(