LET_UNDERSCORE_LOCK in rustc_lint::let_underscore - Rust
Description: The `let_underscore_lock` lint checks for statements which don’t bind a mutex to anything, causing the lock to be released immediately instead of at end of scope, which is typically incorrect.

Skip to main content

## LET_UNDERSCORE_LOCK

# Static LET_UNDERSCORE_LOCK

Source

    pub static LET_UNDERSCORE_LOCK: &Lint

Expand description

The `let_underscore_lock` lint checks for statements which don’t bind a mutex to anything, causing the lock to be released immediately instead of at end of scope, which is typically incorrect.

#### §Example

ⓘ

    use std::sync::{Arc, Mutex};
    use std::thread;
    let data = Arc::new(Mutex::new(0));

    thread::spawn(move || {
        // The lock is immediately released instead of at the end of the
        // scope, which is probably not intended.
        let _ = data.lock().unwrap();
        println!("doing some work");
        let mut lock = data.lock().unwrap();
        *lock += 1;
    });

{{produces}}

#### §Explanation

Statements which assign an expression to an underscore causes the expression to immediately drop instead of extending the expression’s lifetime to the end of the scope. This is usually unintended, especially for types like `MutexGuard`, which are typically used to lock a mutex for the duration of an entire scope.

If you want to extend the expression’s lifetime to the end of the scope, assign an underscore-prefixed name (such as `_foo`) to the expression. If you do actually want to drop the expression immediately, then calling `std::mem::drop` on the expression is clearer and helps convey intent.