diff options
Diffstat (limited to 'vendor/backtrace-ext')
| -rw-r--r-- | vendor/backtrace-ext/.cargo-checksum.json | 1 | ||||
| -rw-r--r-- | vendor/backtrace-ext/Cargo.lock | 515 | ||||
| -rw-r--r-- | vendor/backtrace-ext/Cargo.toml | 27 | ||||
| -rw-r--r-- | vendor/backtrace-ext/README.md | 8 | ||||
| -rw-r--r-- | vendor/backtrace-ext/examples/miette.rs | 99 | ||||
| -rw-r--r-- | vendor/backtrace-ext/src/lib.rs | 277 | ||||
| -rw-r--r-- | vendor/backtrace-ext/src/test.rs | 524 |
7 files changed, 1451 insertions, 0 deletions
diff --git a/vendor/backtrace-ext/.cargo-checksum.json b/vendor/backtrace-ext/.cargo-checksum.json new file mode 100644 index 0000000..bde552e --- /dev/null +++ b/vendor/backtrace-ext/.cargo-checksum.json @@ -0,0 +1 @@ +{"files":{"Cargo.lock":"e6108103e5de7a31784d19ff1ce5f208f5ba926da8d49991f11f6b9f6b3a7a6a","Cargo.toml":"6c19e27c8d3f3c65ae6720d5715036faa3ab6f6187853d125e24d5ef5295d524","README.md":"0545686a94177567dd9c957f137256b3d49eba77560f3b12a4b5c6c8d6546179","examples/miette.rs":"9f5e1c803a14c742f37e18b6ec965b461646a1cc156c908fa7229f4e01958220","src/lib.rs":"eb0c7d3a660108416db915d94388e384c149161fa8145e8e276add714648f01a","src/test.rs":"cca4c8198af8a71e64174ba4c587fd1f3d2f3e524520c6a99b75675607ba624c"},"package":"537beee3be4a18fb023b570f80e3ae28003db9167a751266b259926e25539d50"}
\ No newline at end of file diff --git a/vendor/backtrace-ext/Cargo.lock b/vendor/backtrace-ext/Cargo.lock new file mode 100644 index 0000000..3f71074 --- /dev/null +++ b/vendor/backtrace-ext/Cargo.lock @@ -0,0 +1,515 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "addr2line" +version = "0.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a76fd60b23679b7d19bd066031410fb7e458ccc5e958eb5c325888ce4baedc97" +dependencies = [ + "gimli", +] + +[[package]] +name = "adler" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe" + +[[package]] +name = "ahash" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47" +dependencies = [ + "getrandom", + "once_cell", + "version_check", +] + +[[package]] +name = "aho-corasick" +version = "0.7.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc936419f96fa211c1b9166887b38e5e40b19958e5b895be7c1f93adec7071ac" +dependencies = [ + "memchr", +] + +[[package]] +name = "backtrace" +version = "0.3.67" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "233d376d6d185f2a3093e58f283f60f880315b6c60075b01f36b3b85154564ca" +dependencies = [ + "addr2line", + "cc", + "cfg-if", + "libc", + "miniz_oxide", + "object", + "rustc-demangle", +] + +[[package]] +name = "backtrace-ext" +version = "0.2.1" +dependencies = [ + "backtrace", + "miette", + "thiserror", +] + +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + +[[package]] +name = "cc" +version = "1.0.79" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50d30906286121d95be3d479533b458f87493b30a4b5f79a607db8f5d11aa91f" + +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + +[[package]] +name = "errno" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50d6a0976c999d473fe89ad888d5a284e55366d9dc9038b1ba2aa15128c4afa0" +dependencies = [ + "errno-dragonfly", + "libc", + "windows-sys", +] + +[[package]] +name = "errno-dragonfly" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf" +dependencies = [ + "cc", + "libc", +] + +[[package]] +name = "getrandom" +version = "0.2.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31" +dependencies = [ + "cfg-if", + "libc", + "wasi", +] + +[[package]] +name = "gimli" +version = "0.27.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad0a93d233ebf96623465aad4046a8d3aa4da22d4f4beba5388838c8a434bbb4" + +[[package]] +name = "hashbrown" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" +dependencies = [ + "ahash", +] + +[[package]] +name = "hermit-abi" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fed44880c466736ef9a5c5b5facefb5ed0785676d0c02d612db14e54f0d84286" + +[[package]] +name = "io-lifetimes" +version = "1.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09270fd4fa1111bc614ed2246c7ef56239a3063d5be0d1ec3b589c505d400aeb" +dependencies = [ + "hermit-abi", + "libc", + "windows-sys", +] + +[[package]] +name = "is-terminal" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "256017f749ab3117e93acb91063009e1f1bb56d03965b14c2c8df4eb02c524d8" +dependencies = [ + "hermit-abi", + "io-lifetimes", + "rustix", + "windows-sys", +] + +[[package]] +name = "is_ci" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "616cde7c720bb2bb5824a224687d8f77bfd38922027f01d825cd7453be5099fb" + +[[package]] +name = "libc" +version = "0.2.140" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "99227334921fae1a979cf0bfdfcc6b3e5ce376ef57e16fb6fb3ea2ed6095f80c" + +[[package]] +name = "linux-raw-sys" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d59d8c75012853d2e872fb56bc8a2e53718e2cafe1a4c823143141c6d90c322f" + +[[package]] +name = "memchr" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d" + +[[package]] +name = "miette" +version = "5.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "07749fb52853e739208049fb513287c6f448de9103dfa78b05ae01f2fc5809bb" +dependencies = [ + "backtrace", + "is-terminal", + "miette-derive", + "once_cell", + "owo-colors", + "supports-color", + "supports-hyperlinks", + "supports-unicode", + "terminal_size", + "textwrap", + "thiserror", + "unicode-width", +] + +[[package]] +name = "miette-derive" +version = "5.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2a07ad93a80d1b92bb44cb42d7c49b49c9aab1778befefad49cceb5e4c5bf460" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "miniz_oxide" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b275950c28b37e794e8c55d88aeb5e139d0ce23fdbbeda68f8d7174abdf9e8fa" +dependencies = [ + "adler", +] + +[[package]] +name = "object" +version = "0.30.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea86265d3d3dcb6a27fc51bd29a4bf387fae9d2986b823079d4986af253eb439" +dependencies = [ + "memchr", +] + +[[package]] +name = "once_cell" +version = "1.17.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7e5500299e16ebb147ae15a00a942af264cf3688f47923b8fc2cd5858f23ad3" + +[[package]] +name = "owo-colors" +version = "3.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c1b04fb49957986fdce4d6ee7a65027d55d4b6d2265e5848bbb507b58ccfdb6f" + +[[package]] +name = "proc-macro2" +version = "1.0.54" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e472a104799c74b514a57226160104aa483546de37e839ec50e3c2e41dd87534" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4424af4bf778aae2051a77b60283332f386554255d722233d09fbfc7e30da2fc" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "regex" +version = "1.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b1f693b24f6ac912f4893ef08244d70b6067480d2f1a46e950c9691e6749d1d" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.6.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1" + +[[package]] +name = "rustc-demangle" +version = "0.1.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4a36c42d1873f9a77c53bde094f9664d9891bc604a45b4798fd2c389ed12e5b" + +[[package]] +name = "rustix" +version = "0.37.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0e78cc525325c06b4a7ff02db283472f3c042b7ff0c391f96c6d5ac6f4f91b75" +dependencies = [ + "bitflags", + "errno", + "io-lifetimes", + "libc", + "linux-raw-sys", + "windows-sys", +] + +[[package]] +name = "smawk" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f67ad224767faa3c7d8b6d91985b78e70a1324408abcb1cfcc2be4c06bc06043" + +[[package]] +name = "supports-color" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4950e7174bffabe99455511c39707310e7e9b440364a2fcb1cc21521be57b354" +dependencies = [ + "is-terminal", + "is_ci", +] + +[[package]] +name = "supports-hyperlinks" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b4806e0b03b9906e76b018a5d821ebf198c8e9dc0829ed3328eeeb5094aed60" +dependencies = [ + "is-terminal", +] + +[[package]] +name = "supports-unicode" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b6c2cb240ab5dd21ed4906895ee23fe5a48acdbd15a3ce388e7b62a9b66baf7" +dependencies = [ + "is-terminal", +] + +[[package]] +name = "syn" +version = "1.0.109" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "2.0.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "79d9531f94112cfc3e4c8f5f02cb2b58f72c97b7efd85f70203cc6d8efda5927" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "terminal_size" +version = "0.1.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "633c1a546cee861a1a6d0dc69ebeca693bf4296661ba7852b9d21d159e0506df" +dependencies = [ + "libc", + "winapi", +] + +[[package]] +name = "textwrap" +version = "0.15.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7b3e525a49ec206798b40326a44121291b530c963cfb01018f63e135bac543d" +dependencies = [ + "smawk", + "unicode-linebreak", + "unicode-width", +] + +[[package]] +name = "thiserror" +version = "1.0.40" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "978c9a314bd8dc99be594bc3c175faaa9794be04a5a5e153caba6915336cebac" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.40" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9456a42c5b0d803c8cd86e73dd7cc9edd429499f37a3550d286d5e86720569f" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.12", +] + +[[package]] +name = "unicode-ident" +version = "1.0.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5464a87b239f13a63a501f2701565754bae92d243d4bb7eb12f6d57d2269bf4" + +[[package]] +name = "unicode-linebreak" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c5faade31a542b8b35855fff6e8def199853b2da8da256da52f52f1316ee3137" +dependencies = [ + "hashbrown", + "regex", +] + +[[package]] +name = "unicode-width" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b" + +[[package]] +name = "version_check" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f" + +[[package]] +name = "wasi" +version = "0.11.0+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows-sys" +version = "0.45.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0" +dependencies = [ + "windows-targets", +] + +[[package]] +name = "windows-targets" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071" +dependencies = [ + "windows_aarch64_gnullvm", + "windows_aarch64_msvc", + "windows_i686_gnu", + "windows_i686_msvc", + "windows_x86_64_gnu", + "windows_x86_64_gnullvm", + "windows_x86_64_msvc", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43" + +[[package]] +name = "windows_i686_gnu" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f" + +[[package]] +name = "windows_i686_msvc" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0" diff --git a/vendor/backtrace-ext/Cargo.toml b/vendor/backtrace-ext/Cargo.toml new file mode 100644 index 0000000..2195a36 --- /dev/null +++ b/vendor/backtrace-ext/Cargo.toml @@ -0,0 +1,27 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2018" +rust-version = "1.56" +name = "backtrace-ext" +version = "0.2.1" +description = "minor conveniences on top of the backtrace crate" +license = "MIT OR Apache-2.0" +repository = "https://github.com/gankra/backtrace-ext" +[dependencies.backtrace] +version = "0.3.61" +[dev-dependencies.miette] +version = "5.6.0" +features = ["fancy"] + +[dev-dependencies.thiserror] +version = "1.0.40" diff --git a/vendor/backtrace-ext/README.md b/vendor/backtrace-ext/README.md new file mode 100644 index 0000000..df25c6e --- /dev/null +++ b/vendor/backtrace-ext/README.md @@ -0,0 +1,8 @@ +# backtrace-ext + +[](https://crates.io/crates/backtrace-ext) +[](https://docs.rs/backtrace-ext) +[](https://github.com/gankra/backtrace-ext/actions/workflows/ci.yml) + +Minor conveniences on top of the backtrace crate, because I don't want to copy-paste this everywhere +I override a panic handler.
\ No newline at end of file diff --git a/vendor/backtrace-ext/examples/miette.rs b/vendor/backtrace-ext/examples/miette.rs new file mode 100644 index 0000000..ae41982 --- /dev/null +++ b/vendor/backtrace-ext/examples/miette.rs @@ -0,0 +1,99 @@ +use std::fmt::Write; + +use backtrace::Backtrace; +use miette::{Context, Diagnostic, Report}; +use thiserror::Error; + +type Result<T> = std::result::Result<T, Report>; + +#[inline(never)] +fn main() { + set_panic_hook(); + do_thing(); +} + +#[inline(never)] +fn do_thing() { + panic!("ooopssie!!!"); +} + +/// Tells miette to render panics using its rendering engine. +pub fn set_panic_hook() { + std::panic::set_hook(Box::new(move |info| { + let mut message = "Something went wrong".to_string(); + let payload = info.payload(); + if let Some(msg) = payload.downcast_ref::<&str>() { + message = msg.to_string(); + } + if let Some(msg) = payload.downcast_ref::<String>() { + message = msg.clone(); + } + let mut report: Result<()> = Err(Panic(message).into()); + if let Some(loc) = info.location() { + report = report + .with_context(|| format!("at {}:{}:{}", loc.file(), loc.line(), loc.column())); + } + if let Err(err) = report.with_context(|| "Main thread panicked.".to_string()) { + eprintln!("Error: {:?}", err); + } + })); +} + +#[derive(Debug, Error, Diagnostic)] +#[error("{0}{}", Panic::backtrace())] +#[diagnostic(help("set the `RUST_BACKTRACE=1` environment variable to display a backtrace."))] +struct Panic(String); + +impl Panic { + fn backtrace() -> String { + if let Ok(var) = std::env::var("RUST_BACKTRACE") { + if !var.is_empty() && var != "0" { + const HEX_WIDTH: usize = std::mem::size_of::<usize>() + 2; + // Padding for next lines after frame's address + const NEXT_SYMBOL_PADDING: usize = HEX_WIDTH + 6; + let mut backtrace = String::new(); + let trace = Backtrace::new(); + let frames = backtrace_ext::short_frames_strict(&trace).enumerate(); + for (idx, (frame, sub_frames)) in frames { + let ip = frame.ip(); + let _ = write!(backtrace, "\n{:4}: {:2$?}", idx, ip, HEX_WIDTH); + + let symbols = frame.symbols(); + if symbols.is_empty() { + let _ = write!(backtrace, " - <unresolved>"); + continue; + } + + for (idx, symbol) in symbols[sub_frames].iter().enumerate() { + // Print symbols from this address, + // if there are several addresses + // we need to put it on next line + if idx != 0 { + let _ = write!(backtrace, "\n{:1$}", "", NEXT_SYMBOL_PADDING); + } + + if let Some(name) = symbol.name() { + let _ = write!(backtrace, " - {}", name); + } else { + let _ = write!(backtrace, " - <unknown>"); + } + + // See if there is debug information with file name and line + if let (Some(file), Some(line)) = (symbol.filename(), symbol.lineno()) { + let _ = write!( + backtrace, + "\n{:3$}at {}:{}", + "", + file.display(), + line, + NEXT_SYMBOL_PADDING + ); + } + } + } + return backtrace; + } + } + "".into() + } +} diff --git a/vendor/backtrace-ext/src/lib.rs b/vendor/backtrace-ext/src/lib.rs new file mode 100644 index 0000000..b04c59d --- /dev/null +++ b/vendor/backtrace-ext/src/lib.rs @@ -0,0 +1,277 @@ +//! Minor conveniences on top of the backtrace crate +//! +//! See [`short_frames_strict`][] for details. +use backtrace::*; +use std::ops::Range; + +#[cfg(test)] +mod test; + +/// Gets an iterator over the frames that are part of Rust's "short backtrace" range. +/// If no such range is found, the full stack is yielded. +/// +/// Rust generally tries to include special frames on the stack called `rust_end_short_backtrace` +/// and `rust_begin_short_backtrace` which delimit the "real" stackframes from "gunk" stackframes +/// like setting up main and invoking the panic runtime. This yields all the "real" frames between +/// those two (which theoretically can be nothing with enough optimization, although that's unlikely +/// for any non-trivial program). +/// +/// If only one of the special frames is present we will only clamp one side of the stack +/// (similar to `a..` or `..a`). If the special frames are in the wrong order we will discard +/// them and produce the full stack. If multiple versions of a special frame are found +/// (I've seen it in the wild), we will pick the "innermost" ones, producing the smallest +/// possible backtrace (and excluding all special frames from the output). +/// +/// Each element of the iterator includes a Range which you should use to slice +/// the frame's `symbols()` array. This handles the theoretical situation where "real" frames +/// got inlined together with the special marker frames. I want to believe this can't happen +/// but you can never trust backtraces to be reasonable! We will never yield a Frame to you +/// with an empty Range. +/// +/// Note that some "gunk" frames may still be found within the short backtrace, as there is still some +/// platform-specific and optimization-specific glue around the edges because compilers are +/// complicated and nothing's perfect. This can include: +/// +/// * `core::ops::function::FnOnce::call_once` +/// * `std::panicking::begin_panic_handler` +/// * `core::panicking::panic_fmt` +/// * `rust_begin_unwind` +/// +/// In the future we may introduce a non-strict short_frames which heuristically filters +/// those frames out too. Until then, the strict approach is safe. +/// +/// # Example +/// +/// Here's an example simple "short backtrace" implementation. +/// Note the use of `sub_frames` for the inner loop to restrict `symbols`! +/// +/// This example is based off of code found in `miette` (Apache-2.0), which itself +/// copied the logic from `human-panic` (MIT/Apache-2.0). +/// +/// FIXME: it would be nice if this example consulted `RUST_BACKTRACE=full`, +/// and maybe other vars used by rust's builtin panic handler..? +/// +/// ``` +/// fn backtrace() -> String { +/// use std::fmt::Write; +/// if let Ok(var) = std::env::var("RUST_BACKTRACE") { +/// if !var.is_empty() && var != "0" { +/// const HEX_WIDTH: usize = std::mem::size_of::<usize>() + 2; +/// // Padding for next lines after frame's address +/// const NEXT_SYMBOL_PADDING: usize = HEX_WIDTH + 6; +/// let mut backtrace = String::new(); +/// let trace = backtrace::Backtrace::new(); +/// let frames = backtrace_ext::short_frames_strict(&trace).enumerate(); +/// for (idx, (frame, subframes)) in frames { +/// let ip = frame.ip(); +/// let _ = write!(backtrace, "\n{:4}: {:2$?}", idx, ip, HEX_WIDTH); +/// +/// let symbols = frame.symbols(); +/// if symbols.is_empty() { +/// let _ = write!(backtrace, " - <unresolved>"); +/// continue; +/// } +/// +/// for (idx, symbol) in symbols[subframes].iter().enumerate() { +/// // Print symbols from this address, +/// // if there are several addresses +/// // we need to put it on next line +/// if idx != 0 { +/// let _ = write!(backtrace, "\n{:1$}", "", NEXT_SYMBOL_PADDING); +/// } +/// +/// if let Some(name) = symbol.name() { +/// let _ = write!(backtrace, " - {}", name); +/// } else { +/// let _ = write!(backtrace, " - <unknown>"); +/// } +/// +/// // See if there is debug information with file name and line +/// if let (Some(file), Some(line)) = (symbol.filename(), symbol.lineno()) { +/// let _ = write!( +/// backtrace, +/// "\n{:3$}at {}:{}", +/// "", +/// file.display(), +/// line, +/// NEXT_SYMBOL_PADDING +/// ); +/// } +/// } +/// } +/// return backtrace; +/// } +/// } +/// "".into() +/// } +/// ``` +pub fn short_frames_strict( + backtrace: &Backtrace, +) -> impl Iterator<Item = (&BacktraceFrame, Range<usize>)> { + short_frames_strict_impl(backtrace) +} + +pub(crate) fn short_frames_strict_impl<B: Backtraceish>( + backtrace: &B, +) -> impl Iterator<Item = (&B::Frame, Range<usize>)> { + // Search for the special frames + let mut short_start = None; + let mut short_end = None; + let frames = backtrace.frames(); + for (frame_idx, frame) in frames.iter().enumerate() { + let symbols = frame.symbols(); + for (subframe_idx, frame) in symbols.iter().enumerate() { + if let Some(name) = frame.name_str() { + // Yes these ARE backwards, and that's intentional! We want to print the frames from + // "newest to oldest" (show what panicked first), and that's the order that Backtrace + // gives us, but these magic labels view the stack in the opposite order. So we just + // swap it once here and forget about that weirdness. + // + // Note that due to platform/optimization wobblyness you can end up with multiple frames + // that contain these names in sequence. If that happens we just want to pick the two + // that are closest together. For the start that means just using the last one we found, + // and for the end that means taking the first one we find. + if name.contains("rust_end_short_backtrace") { + short_start = Some((frame_idx, subframe_idx)); + } + if name.contains("rust_begin_short_backtrace") && short_end.is_none() { + short_end = Some((frame_idx, subframe_idx)); + } + } + } + } + + // Check if these are in the right order, if they aren't, discard them + // This also handles the mega-cursed case of "someone made a symbol with both names + // so actually they're the exact same subframe". + if let (Some(start), Some(end)) = (short_start, short_end) { + if start >= end { + short_start = None; + short_end = None; + } + } + + // By default we want to produce a full stack trace and now we'll try to clamp it. + let mut first_frame = 0usize; + let mut first_subframe = 0usize; + // NOTE: this is INCLUSIVE + let mut last_frame = frames.len().saturating_sub(1); + // NOTE: this is EXCLUSIVE + let mut last_subframe_excl = backtrace + .frames() + .last() + .map(|frame| frame.symbols().len()) + .unwrap_or(0); + + // This code tries to be really paranoid about boundary conditions although in practice + // most of them are impossible because there's always going to be gunk on either side + // of the short backtrace to smooth out the boundaries, and panic_fmt is basically + // impossible to optimize out. Still, don't trust backtracers!!! + // + // This library has a fuckton of tests to try to catch all the little corner cases here. + + // If we found the start bound... + if let Some((idx, sub_idx)) = short_start { + if frames[idx].symbols().len() == sub_idx + 1 { + // If it was the last subframe of this frame, we want to just + // use the whole next frame! It's ok if this takes us to `first_frame = len`, + // that will be properly handled as an empty output + first_frame = idx + 1; + first_subframe = 0; + } else { + // Otherwise use this frame, and all the subframes after it + first_frame = idx; + first_subframe = sub_idx + 1; + } + } + + // If we found the end bound... + if let Some((idx, sub_idx)) = short_end { + if sub_idx == 0 { + // If it was the first subframe of this frame, we want to just + // use the whole previous frame! + if idx == 0 { + // If we were *also* on the first frame, set subframe_excl + // to 0, indicating an empty output + last_frame = 0; + last_subframe_excl = 0; + } else { + last_frame = idx - 1; + last_subframe_excl = frames[last_frame].symbols().len(); + } + } else { + // Otherwise use this frame (no need subframe math, exclusive bound!) + last_frame = idx; + last_subframe_excl = sub_idx; + } + } + + // If the two subframes managed to perfectly line up with eachother, just + // throw everything out and yield an empty range. We don't need to fix any + // other values at this point as they won't be used for anything with an + // empty iterator + let final_frames = { + let start = (first_frame, first_subframe); + let end = (last_frame, last_subframe_excl); + if start == end { + &frames[0..0] + } else { + &frames[first_frame..=last_frame] + } + }; + + // Get the index of the last frame when starting from the first frame + let adjusted_last_frame = last_frame.saturating_sub(first_frame); + + // finally do the iteration + final_frames.iter().enumerate().map(move |(idx, frame)| { + // Default to all subframes being yielded + let mut sub_start = 0; + let mut sub_end_excl = frame.symbols().len(); + // If we're on first frame, apply its subframe clamp + if idx == 0 { + sub_start = first_subframe; + } + // If we're on the last frame, apply its subframe clamp + if idx == adjusted_last_frame { + sub_end_excl = last_subframe_excl; + } + (frame, sub_start..sub_end_excl) + }) +} + +pub(crate) trait Backtraceish { + type Frame: Frameish; + fn frames(&self) -> &[Self::Frame]; +} + +pub(crate) trait Frameish { + type Symbol: Symbolish; + fn symbols(&self) -> &[Self::Symbol]; +} + +pub(crate) trait Symbolish { + fn name_str(&self) -> Option<&str>; +} + +impl Backtraceish for Backtrace { + type Frame = BacktraceFrame; + fn frames(&self) -> &[Self::Frame] { + self.frames() + } +} + +impl Frameish for BacktraceFrame { + type Symbol = BacktraceSymbol; + fn symbols(&self) -> &[Self::Symbol] { + self.symbols() + } +} + +impl Symbolish for BacktraceSymbol { + // We need to shortcut SymbolName here because + // HRTB isn't in our msrv + fn name_str(&self) -> Option<&str> { + self.name().and_then(|n| n.as_str()) + } +} diff --git a/vendor/backtrace-ext/src/test.rs b/vendor/backtrace-ext/src/test.rs new file mode 100644 index 0000000..d4d4112 --- /dev/null +++ b/vendor/backtrace-ext/src/test.rs @@ -0,0 +1,524 @@ +use super::*; + +type BT = &'static [&'static [&'static str]]; + +impl Backtraceish for BT { + type Frame = &'static [&'static str]; + fn frames(&self) -> &[Self::Frame] { + self + } +} + +impl Frameish for &'static [&'static str] { + type Symbol = &'static str; + fn symbols(&self) -> &[Self::Symbol] { + self + } +} + +impl Symbolish for &'static str { + fn name_str(&self) -> Option<&str> { + Some(self) + } +} + +fn process(bt: BT) -> Vec<&'static str> { + let mut result = vec![]; + for (frame, subframes) in short_frames_strict_impl(&bt) { + let symbols = &frame.symbols()[subframes]; + assert!(!symbols.is_empty()); + for symbol in symbols { + result.push(*symbol); + } + } + result +} + +#[test] +fn test_full() { + let bt: BT = &[&["hello"], &["there", "simple"], &["case"]]; + let expected = vec!["hello", "there", "simple", "case"]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_empty() { + let bt: BT = &[]; + let expected: Vec<&str> = vec![]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_cursed_one_true_symbol1() { + let bt: BT = &[ + &["hello"], + &["__rust_end_short_backtrace_rust_begin_short_backtrace"], + &["there"], + ]; + let expected = vec![ + "hello", + "__rust_end_short_backtrace_rust_begin_short_backtrace", + "there", + ]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_cursed_one_true_symbol2() { + let bt: BT = &[ + &["hello"], + &["__rust_begin_short_backtrace_rust_end_short_backtrace"], + &["there"], + ]; + let expected: Vec<&str> = vec![ + "hello", + "__rust_begin_short_backtrace_rust_end_short_backtrace", + "there", + ]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_backwards1() { + let bt: BT = &[ + &["hello"], + &["__rust_begin_short_backtrace"], + &["real"], + &["frames"], + &["rust_end_short_backtrace"], + &["case"], + ]; + let expected = vec![ + "hello", + "__rust_begin_short_backtrace", + "real", + "frames", + "rust_end_short_backtrace", + "case", + ]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_backwards2() { + let bt: BT = &[ + &["hello"], + &["__rust_begin_short_backtrace", "real", "frames"], + &["rust_end_short_backtrace"], + &["case"], + ]; + let expected = vec![ + "hello", + "__rust_begin_short_backtrace", + "real", + "frames", + "rust_end_short_backtrace", + "case", + ]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_backwards3() { + let bt: BT = &[ + &["hello"], + &["__rust_begin_short_backtrace"], + &["real", "frames", "rust_end_short_backtrace"], + &["case"], + ]; + let expected = vec![ + "hello", + "__rust_begin_short_backtrace", + "real", + "frames", + "rust_end_short_backtrace", + "case", + ]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_backwards4() { + let bt: BT = &[ + &["hello"], + &[ + "__rust_begin_short_backtrace", + "real", + "frames", + "rust_end_short_backtrace", + ], + &["case"], + ]; + let expected = vec![ + "hello", + "__rust_begin_short_backtrace", + "real", + "frames", + "rust_end_short_backtrace", + "case", + ]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_begin_clamp_simple() { + let bt: BT = &[&["hello"], &["__rust_begin_short_backtrace"], &["case"]]; + let expected = vec!["hello"]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_begin_clamp_left_edge() { + let bt: BT = &[&["__rust_begin_short_backtrace"], &["case"]]; + let expected: Vec<&str> = vec![]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_begin_clamp_right_edge() { + let bt: BT = &[&["hello"], &["__rust_begin_short_backtrace"]]; + let expected = vec!["hello"]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_begin_clamp_empty() { + let bt: BT = &[&["__rust_begin_short_backtrace"]]; + let expected: Vec<&str> = vec![]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_begin_clamp_sub() { + let bt: BT = &[ + &["real"], + &["frames", "core::rust_begin_short_backtrace", "junk"], + &["junk"], + ]; + let expected = vec!["real", "frames"]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_end_clamp_simple() { + let bt: BT = &[&["hello"], &["__rust_end_short_backtrace"], &["case"]]; + let expected = vec!["case"]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_end_clamp_left_edge() { + let bt: BT = &[&["_rust_end_short_backtrace"], &["case"]]; + let expected = vec!["case"]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_end_clamp_right_edge() { + let bt: BT = &[&["hello"], &["__rust_end_short_backtrace"]]; + let expected: Vec<&str> = vec![]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_end_clamp_empty() { + let bt: BT = &[&["__rust_end_short_backtrace"]]; + let expected: Vec<&str> = vec![]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_end_clamp_sub() { + let bt: BT = &[ + &["junk"], + &["junk", "__rust_end_short_backtrace", "real"], + &["frames"], + ]; + let expected = vec!["real", "frames"]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_both_simple() { + let bt: BT = &[ + &["hello"], + &["__rust_end_short_backtrace"], + &["real"], + &["frames"], + &["rust_begin_short_backtrace"], + &["case"], + ]; + let expected = vec!["real", "frames"]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_both_multiball_various() { + let bt: BT = &[ + &["hello"], + &["__rust_end_short_backtrace"], + &["core::rust_end_short_backtrace"], + &["junk"], + &["rust_end_short_backtrace"], + &["real"], + &["frames"], + &["rust_begin_short_backtrace"], + &["_rust_begin_short_backtrace"], + &["junk"], + &["core::rust_begin_short_backtrace"], + &["case"], + ]; + let expected = vec!["real", "frames"]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_both_multiball_identical() { + let bt: BT = &[ + &["hello"], + &["rust_end_short_backtrace"], + &["rust_end_short_backtrace"], + &["real"], + &["frames"], + &["rust_begin_short_backtrace"], + &["rust_begin_short_backtrace"], + &["case"], + ]; + let expected = vec!["real", "frames"]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_both_multiball_invert1() { + let bt: BT = &[ + &["hello"], + &["rust_end_short_backtrace"], + &["real"], + &["frames"], + &["rust_begin_short_backtrace"], + &["junk"], + &["rust_end_short_backtrace"], + &["case"], + ]; + let expected = vec![ + "hello", + "rust_end_short_backtrace", + "real", + "frames", + "rust_begin_short_backtrace", + "junk", + "rust_end_short_backtrace", + "case", + ]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_both_multiball_invert2() { + let bt: BT = &[ + &["hello"], + &["rust_begin_short_backtrace"], + &["junk"], + &["rust_end_short_backtrace"], + &["real"], + &["frames"], + &["rust_begin_short_backtrace"], + &["case"], + ]; + let expected = vec![ + "hello", + "rust_begin_short_backtrace", + "junk", + "rust_end_short_backtrace", + "real", + "frames", + "rust_begin_short_backtrace", + "case", + ]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_both_adjacent() { + let bt: BT = &[ + &["hello"], + &["__rust_end_short_backtrace"], + &["rust_begin_short_backtrace"], + &["case"], + ]; + let expected: Vec<&str> = vec![]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_both_left_edge() { + let bt: BT = &[ + &["__rust_end_short_backtrace"], + &["real"], + &["frames"], + &["rust_begin_short_backtrace"], + &["case"], + ]; + let expected = vec!["real", "frames"]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_both_right_edge() { + let bt: BT = &[ + &["hello"], + &["__rust_end_short_backtrace"], + &["real"], + &["frames"], + &["rust_begin_short_backtrace"], + ]; + let expected = vec!["real", "frames"]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_both_spanned() { + let bt: BT = &[ + &["__rust_end_short_backtrace"], + &["real"], + &["frames"], + &["__rust_begin_short_backtrace"], + ]; + let expected = vec!["real", "frames"]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_both_spanned_empty() { + let bt: BT = &[ + &["rust_end_short_backtrace"], + &["rust_begin_short_backtrace"], + ]; + let expected: Vec<&str> = vec![]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_one_super_frame_2() { + let bt: BT = &[&[ + "rust_end_short_backtrace", + "real", + "frames", + "rust_begin_short_backtrace", + ]]; + let expected = vec!["real", "frames"]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_one_super_frame_1() { + let bt: BT = &[&[ + "rust_end_short_backtrace", + "real", + "rust_begin_short_backtrace", + ]]; + let expected = vec!["real"]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_one_super_frame_0() { + let bt: BT = &[&["rust_end_short_backtrace", "rust_begin_short_backtrace"]]; + let expected: Vec<&str> = vec![]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_complex1() { + let bt: BT = &[ + &["junk"], + &["junk", "__rust_end_short_backtrace", "real"], + &["frames"], + &["here", "__rust_begin_short_backtrace", "junk"], + &["junk"], + ]; + let expected = vec!["real", "frames", "here"]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_complex2() { + let bt: BT = &[ + &["junk"], + &["__rust_end_short_backtrace", "real"], + &["frames"], + &["here", "__rust_begin_short_backtrace", "junk"], + &["junk"], + ]; + let expected = vec!["real", "frames", "here"]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_complex3() { + let bt: BT = &[ + &["junk"], + &["junk", "__rust_end_short_backtrace", "real"], + &["frames"], + &["here", "__rust_begin_short_backtrace"], + &["junk"], + ]; + let expected = vec!["real", "frames", "here"]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_complex4() { + let bt: BT = &[ + &["junk"], + &["junk", "__rust_end_short_backtrace"], + &["real", "frames"], + &["here", "__rust_begin_short_backtrace"], + &["junk"], + ]; + let expected = vec!["real", "frames", "here"]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_complex5() { + let bt: BT = &[ + &["junk"], + &["junk", "__rust_end_short_backtrace", "real"], + &["frames", "here"], + &["__rust_begin_short_backtrace"], + &["junk"], + ]; + let expected = vec!["real", "frames", "here"]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_complex6() { + let bt: BT = &[ + &["junk"], + &[ + "junk", + "__rust_end_short_backtrace", + "real", + "frames", + "here", + ], + &["__rust_begin_short_backtrace"], + &["junk"], + ]; + let expected = vec!["real", "frames", "here"]; + assert_eq!(process(bt), expected); +} + +#[test] +fn test_complex7() { + let bt: BT = &[ + &["junk"], + &["junk", "__rust_end_short_backtrace"], + &["real", "frames", "here", "__rust_begin_short_backtrace"], + &["junk"], + ]; + let expected = vec!["real", "frames", "here"]; + assert_eq!(process(bt), expected); +} |