Error when using debug_assert! and async function

[gliderkite]

I'm getting an error with the following code:

use std::path::{Path, PathBuf};
use tokio::fs;

async fn exists(path: impl AsRef<Path>) -> bool {
    fs::metadata(path).await.is_ok()
}

#[tokio::main]
async fn main() {
    let path = PathBuf::from("");
    debug_assert!(!exists(&path).await);
}

error: do not call a function with mutable arguments inside of `debug_assert!`
  --> src/main.rs:11:20
   |
11 |     debug_assert!(!exists(&path).await);
   |                    ^^^^^^^^^^^^^^^^^^^
   |
   = note: `#[deny(clippy::debug_assert_with_mut_call)]` on by default
   = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#debug_assert_with_mut_call

error: aborting due to previous error

Note that this doesn't occur with the equivalent blocking version:

use std::path::{Path, PathBuf};

fn exists(path: impl AsRef<Path>) -> bool {
    path.as_ref().exists()
}

fn main() {
    let path = PathBuf::from("");
    debug_assert!(!exists(&path));
}

Is this expected behaviour?

[flip1995]

This is kind of expected, since the behavior of your code will differ in debug and release mode. While the async version will block, until exists is ready in debug mode, it will not block on this in release mode.

But since this cannot lead to bugs, the lint is intended to detect, we should special case .await and bail out.

[gliderkite]

If I understood you correctly, I'm not sure that bailing out whenever we encounter .await, independently if the method is called with a mutable parameter, is the way to go. The reason being that in a situation like:

use std::path::PathBuf;

async fn pop_mut(path: &mut PathBuf) -> bool {
    path.pop()
}

#[tokio::main]
async fn main() {
    let mut path = PathBuf::from("");
    debug_assert!(!pop_mut(&mut path).await);
}

I'd still want the warning to be raised.

[flip1995]

Ah good point! I'll fix my fix 👍

Edit: Done.