Steps to reproduce:

mkdir /tmp/memory-error && cd /tmp/memory-error
cargo init --lib
cargo +nightly careful test --no-run
valgrind --track-origins=yes target/debug/deps/memory_error-394e695bdd4a1e0f

Valgrind output:

==741342== Memcheck, a memory error detector
==741342== Copyright (C) 2002-2022, and GNU GPL'd, by Julian Seward et al.
==741342== Using Valgrind-3.19.0 and LibVEX; rerun with -h for copyright info
==741342== Command: target/debug/deps/memory_error-394e695bdd4a1e0f
==741342== 
==741342== Conditional jump or move depends on uninitialised value(s)
==741342==    at 0x16673A: runtime<u8> (raw.rs:93)
==741342==    by 0x16673A: from_raw_parts<u8> (intrinsics.rs:2220)
==741342==    by 0x16673A: deref<u8, alloc::alloc::Global> (mod.rs:2533)
==741342==    by 0x16673A: index (string.rs:2185)
==741342==    by 0x16673A: eq (string.rs:2185)
==741342==    by 0x16673A: eq (lib.rs:626)
==741342==    by 0x16673A: eq<getopts::Name, getopts::Name> (lib.rs:933)
==741342==    by 0x16673A: {closure#0} (lib.rs:933)
==741342==    by 0x16673A: position<getopts::Opt, getopts::find_opt::{closure_env#0}> (macros.rs:295)
==741342==    by 0x16673A: getopts::find_opt (lib.rs:933)
==741342==    by 0x166084: getopts::Matches::opt_vals (lib.rs:797)
==741342==    by 0x16634A: getopts::Matches::opt_present (lib.rs:813)
==741342==    by 0x13C548: test::cli::parse_opts (cli.rs:207)
==741342==    by 0x15A0FC: test::test_main (lib.rs:95)
==741342==    by 0x15B0D1: test::test_main_static (lib.rs:131)
==741342==    by 0x123112: memory_error::main (lib.rs:1)
==741342==    by 0x12307A: core::ops::function::FnOnce::call_once (function.rs:251)
==741342==    by 0x12315D: std::sys_common::backtrace::__rust_begin_short_backtrace (backtrace.rs:122)
==741342==    by 0x122CE0: std::rt::lang_start::{{closure}} (rt.rs:166)
==741342==    by 0x18AA53: call_once<(), (dyn core::ops::function::Fn<(), Output=i32> + core::marker::Sync + core::panic::unwind_safe::RefUnwindSafe)> (function.rs:286)
==741342==    by 0x18AA53: do_call<&(dyn core::ops::function::Fn<(), Output=i32> + core::marker::Sync + core::panic::unwind_safe::RefUnwindSafe), i32> (panicking.rs:464)
==741342==    by 0x18AA53: try<i32, &(dyn core::ops::function::Fn<(), Output=i32> + core::marker::Sync + core::panic::unwind_safe::RefUnwindSafe)> (panicking.rs:428)
==741342==    by 0x18AA53: catch_unwind<&(dyn core::ops::function::Fn<(), Output=i32> + core::marker::Sync + core::panic::unwind_safe::RefUnwindSafe), i32> (panic.rs:137)
==741342==    by 0x18AA53: {closure#2} (rt.rs:148)
==741342==    by 0x18AA53: do_call<std::rt::lang_start_internal::{closure_env#2}, isize> (panicking.rs:464)
==741342==    by 0x18AA53: try<isize, std::rt::lang_start_internal::{closure_env#2}> (panicking.rs:428)
==741342==    by 0x18AA53: catch_unwind<std::rt::lang_start_internal::{closure_env#2}, isize> (panic.rs:137)
==741342==    by 0x18AA53: std::rt::lang_start_internal (rt.rs:148)
==741342==    by 0x122CB9: std::rt::lang_start (rt.rs:165)
==741342==  Uninitialised value was created by a stack allocation
==741342==    at 0x165FE7: getopts::Matches::opt_vals (lib.rs:796)
==741342== 
==741342== Conditional jump or move depends on uninitialised value(s)
==741342==    at 0x16680E: runtime<u8> (raw.rs:93)
==741342==    by 0x16680E: from_raw_parts<u8> (intrinsics.rs:2220)
==741342==    by 0x16680E: deref<u8, alloc::alloc::Global> (mod.rs:2533)
==741342==    by 0x16680E: index (string.rs:2185)
==741342==    by 0x16680E: eq (string.rs:2185)
==741342==    by 0x16680E: eq (lib.rs:626)
==741342==    by 0x16680E: eq<getopts::Name, getopts::Name> (lib.rs:940)
==741342==    by 0x16680E: {closure#1} (lib.rs:940)
==741342==    by 0x16680E: any<getopts::Opt, getopts::find_opt::{closure_env#1}> (macros.rs:242)
==741342==    by 0x16680E: getopts::find_opt (lib.rs:940)
==741342==    by 0x166084: getopts::Matches::opt_vals (lib.rs:797)
==741342==    by 0x16634A: getopts::Matches::opt_present (lib.rs:813)
==741342==    by 0x13C548: test::cli::parse_opts (cli.rs:207)
==741342==    by 0x15A0FC: test::test_main (lib.rs:95)
==741342==    by 0x15B0D1: test::test_main_static (lib.rs:131)
==741342==    by 0x123112: memory_error::main (lib.rs:1)
==741342==    by 0x12307A: core::ops::function::FnOnce::call_once (function.rs:251)
==741342==    by 0x12315D: std::sys_common::backtrace::__rust_begin_short_backtrace (backtrace.rs:122)
==741342==    by 0x122CE0: std::rt::lang_start::{{closure}} (rt.rs:166)
==741342==    by 0x18AA53: call_once<(), (dyn core::ops::function::Fn<(), Output=i32> + core::marker::Sync + core::panic::unwind_safe::RefUnwindSafe)> (function.rs:286)
==741342==    by 0x18AA53: do_call<&(dyn core::ops::function::Fn<(), Output=i32> + core::marker::Sync + core::panic::unwind_safe::RefUnwindSafe), i32> (panicking.rs:464)
==741342==    by 0x18AA53: try<i32, &(dyn core::ops::function::Fn<(), Output=i32> + core::marker::Sync + core::panic::unwind_safe::RefUnwindSafe)> (panicking.rs:428)
==741342==    by 0x18AA53: catch_unwind<&(dyn core::ops::function::Fn<(), Output=i32> + core::marker::Sync + core::panic::unwind_safe::RefUnwindSafe), i32> (panic.rs:137)
==741342==    by 0x18AA53: {closure#2} (rt.rs:148)
==741342==    by 0x18AA53: do_call<std::rt::lang_start_internal::{closure_env#2}, isize> (panicking.rs:464)
==741342==    by 0x18AA53: try<isize, std::rt::lang_start_internal::{closure_env#2}> (panicking.rs:428)
==741342==    by 0x18AA53: catch_unwind<std::rt::lang_start_internal::{closure_env#2}, isize> (panic.rs:137)
==741342==    by 0x18AA53: std::rt::lang_start_internal (rt.rs:148)
==741342==    by 0x122CB9: std::rt::lang_start (rt.rs:165)
==741342==  Uninitialised value was created by a stack allocation
==741342==    at 0x165FE7: getopts::Matches::opt_vals (lib.rs:796)
==741342== 
==741342== Conditional jump or move depends on uninitialised value(s)
==741342==    at 0x16673A: runtime<u8> (raw.rs:93)
==741342==    by 0x16673A: from_raw_parts<u8> (intrinsics.rs:2220)
==741342==    by 0x16673A: deref<u8, alloc::alloc::Global> (mod.rs:2533)
==741342==    by 0x16673A: index (string.rs:2185)
==741342==    by 0x16673A: eq (string.rs:2185)
==741342==    by 0x16673A: eq (lib.rs:626)
==741342==    by 0x16673A: eq<getopts::Name, getopts::Name> (lib.rs:933)
==741342==    by 0x16673A: {closure#0} (lib.rs:933)
==741342==    by 0x16673A: position<getopts::Opt, getopts::find_opt::{closure_env#0}> (macros.rs:295)
==741342==    by 0x16673A: getopts::find_opt (lib.rs:933)
==741342==    by 0x166084: getopts::Matches::opt_vals (lib.rs:797)
==741342==    by 0x166643: getopts::Matches::opt_str (lib.rs:804)
==741342==    by 0x13C764: get_allow_unstable (cli.rs:471)
==741342==    by 0x13C764: parse_opts_impl (cli.rs:252)
==741342==    by 0x13C764: test::cli::parse_opts (cli.rs:214)
==741342==    by 0x15A0FC: test::test_main (lib.rs:95)
==741342==    by 0x15B0D1: test::test_main_static (lib.rs:131)
==741342==    by 0x123112: memory_error::main (lib.rs:1)
==741342==    by 0x12307A: core::ops::function::FnOnce::call_once (function.rs:251)
==741342==    by 0x12315D: std::sys_common::backtrace::__rust_begin_short_backtrace (backtrace.rs:122)
==741342==    by 0x122CE0: std::rt::lang_start::{{closure}} (rt.rs:166)
==741342==    by 0x18AA53: call_once<(), (dyn core::ops::function::Fn<(), Output=i32> + core::marker::Sync + core::panic::unwind_safe::RefUnwindSafe)> (function.rs:286)
==741342==    by 0x18AA53: do_call<&(dyn core::ops::function::Fn<(), Output=i32> + core::marker::Sync + core::panic::unwind_safe::RefUnwindSafe), i32> (panicking.rs:464)
==741342==    by 0x18AA53: try<i32, &(dyn core::ops::function::Fn<(), Output=i32> + core::marker::Sync + core::panic::unwind_safe::RefUnwindSafe)> (panicking.rs:428)
==741342==    by 0x18AA53: catch_unwind<&(dyn core::ops::function::Fn<(), Output=i32> + core::marker::Sync + core::panic::unwind_safe::RefUnwindSafe), i32> (panic.rs:137)
==741342==    by 0x18AA53: {closure#2} (rt.rs:148)
==741342==    by 0x18AA53: do_call<std::rt::lang_start_internal::{closure_env#2}, isize> (panicking.rs:464)
==741342==    by 0x18AA53: try<isize, std::rt::lang_start_internal::{closure_env#2}> (panicking.rs:428)
==741342==    by 0x18AA53: catch_unwind<std::rt::lang_start_internal::{closure_env#2}, isize> (panic.rs:137)
==741342==    by 0x18AA53: std::rt::lang_start_internal (rt.rs:148)
==741342==    by 0x122CB9: std::rt::lang_start (rt.rs:165)
==741342==  Uninitialised value was created by a stack allocation
==741342==    at 0x165FE7: getopts::Matches::opt_vals (lib.rs:796)
==741342== 

running 1 test
test tests::it_works ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.12s

==741342== 
==741342== HEAP SUMMARY:
==741342==     in use at exit: 0 bytes in 0 blocks
==741342==   total heap usage: 479 allocs, 479 frees, 53,506 bytes allocated
==741342== 
==741342== All heap blocks were freed -- no leaks are possible
==741342== 
==741342== For lists of detected and suppressed errors, rerun with: -s
==741342== ERROR SUMMARY: 3 errors from 3 contexts (suppressed: 0 from 0)

I've tried to debug this with gdb and adding prints, but it disappears if you look at it too closely so gave up after a bit of trying

via reddit: running cargo careful test on https://github.com/jeremyletang/rust-sfml seems to result in an error

error[E0460]: found possibly newer version of crate `core` which `link_cplusplus` depends on
--> /home/dew/projects/github/rust-sfml/src/lib.rs:50:1
|
50 | extern crate link_cplusplus;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: perhaps that crate needs to be recompiled?

Compiles and runs the program and standard library with AddressSanitizer on targets that support it. This sanitizer "is not expected to give false positive reports".

I'm trying to use this tool in a nix shell. For some reason, it's sticking it in a write only directory (/tmp/nix-shell.NL1aJs/rustc-build-sysroot.6BErGTCriFwN). Could the sysroot directory be made configurable via flag or environment variable? I'm happy to implement if you'll pull it in :)

Thanks for this interesting tool. It would be great to have a short (realistic) piece of code in the README on which careful would trigger.

Is there some?

via reddit:

I'm using special flags, like:

$ cat .cargo/config.toml 
[build]
rustflags = ["--cfg", "tokio_unstable"]

cargo careful does not seem to use this flag.

This is probably because we are setting rustflags ourselves, cargo stops using the flags from the toml file.

Adds the -Zrandomize-layout flag to CAREFUL_FLAGS. This flag randomizes the layout of repr(Rust) types, to help catch code relying on unatable details of that layout.

Recommended here:

• https://doc.rust-lang.org/beta/unstable-book/compiler-flags/sanitizer.html
• https://github.com/japaric/rust-san

I got a build error on proc-macro-hack, but adding this flag fixed it for me!

I believe this mostly matters for if the stdlib will have these on, since normally it would be on for non-release builds of user code. This perhaps indicates a bug in the stdlib more than in the user's code, but I am not sure if that applies to 100% of the cases this could catch.

Should cargo-careful set a --cfg careful in rustflags? IMO yes, so that extra checking can be enabled. Here are some use cases:

1. When building vendored C code in FFI crates, it's hard[^1] to know if you should turn on assertions, so I usually don't. If the library has extra levels of stronger/slower assertions, I never turn those on (and generally consider it bad for FFI crates to do so without opt-in from the user).

   However, if I can tell a user is using cargo-careful, I can assume they are willing to pay for extra checking, and so I should turn on all the assertions, even if they're slow and/or verify things which would be redundant with safety provided by e.g. Rust's typesystem or something.

2. Even for pure rust, sometimes I have checks only under #[cfg(test)] rather than debug_assertions. This is usually because they're too costly to consider making a user pay for it for their own debugging (perhaps they increase the time complexity of an algorithm, or whatever). Depending on the case (for example, if safety depends on the correctness I very likely would), I may enable this under cargo-careful as well.

I can think of some other use cases as well, of similar reasoning.

[^1]: Sadly, there's no way to reliably detect if the user has debug_assertions enabled in a build script. Ideally cargo would pass CARGO_CFG_DEBUG_ASSERTIONS to build scripts but because of the way it discovers cfgs, it cannot, and IIUC this is unlikely to change. So the closest you get is checking PROFILE for being "debug" or not, which is... not quite right. (Note that the DEBUG env var is for debuginfo, not assertions).

Hi, thanks for the awesome tool!

I'd like to use this in a CI build. The build would go faster and use fewer resources if I were able to download a statically-linked Linux executable from the Github releases, rather than use cargo install. It's actually pretty easy to set up Github Actions to automatically create draft releases with attached static binaries whenever you push a git tag. An example CI setup from one of my own projects is available here: https://github.com/langston-barrett/mdlynx/blob/main/.github/workflows/release.yml

Feel free to close this issue if this doesn't appeal to you or sounds like too much work, I just figured I'd share my use-case and the above link in case it's helpful!