redundant_async_block creates invalid code in async tests

[teor2345]

Summary

cargo clippy --fix creates async functions without braces when I run it on my test code.

I don't know if it's the tokio::test macro, or the returned Result that's causing the bug.

Reproducer

I tried this code:

#[tokio::test(flavor = "multi_thread")]
async fn single_item_checkpoint_list_test() -> Result<(), Report> {
    single_item_checkpoint_list().await
}

#[spandoc::spandoc]
async fn single_item_checkpoint_list() -> Result<(), Report> {
    ...
}

I expected to see this happen:

Fix with correct code.

Instead, this happened:

I got this code without braces:

async fn single_item_checkpoint_list_test() -> Result<(), Report> single_item_checkpoint_list()

...

And when I tried a manual fix:

async fn single_item_checkpoint_list_test() -> Result<(), Report> {
    single_item_checkpoint_list()
}

I got this error:

error[E0308]: mismatched types
     |                                          ---------- expected `std::result::Result<(), ErrReport>` because of return type
     |     ^^^^^^^^^^^^^^^^^^^ expected `Result<(), Report>`, found future
note: calling an async function returns a future
help: consider `await`ing on the `Future`

So I think this is also a false positive, due to a macro on the function.

Version

rustc 1.70.0-nightly (44f518058 2023-03-20)
binary: rustc
commit-hash: 44f5180584404d18058cbbf224c55255db4fdcbb
commit-date: 2023-03-20
host: x86_64-unknown-linux-gnu
release: 1.70.0-nightly
LLVM version: 15.0.7

Additional Labels

@rustbot label +I-suggestion-causes-error

[teor2345]

@rustbot label +I-false-positive

[samueltardieu]

Thanks for the report. In the meantime, when #10490 is merged the lint will be in nursery and won't trigger unless explicitly selected.

@rustbot claim

[samueltardieu]

@teor2345 Could you come up with a minimal reproducer? If you don't have the time to do this, I can start from an example that can be compiled if you have one.

As an example, using the following in a test does not trigger the test, because Clippy ignore the macro output:

#![deny(clippy::redundant_async_block)]
use eyre::Report;

#[tokio::test(flavor = "multi_thread")]
async fn single_item_checkpoint_list_test() -> Result<(), Report> {
    single_item_checkpoint_list().await
}

async fn single_item_checkpoint_list() -> Result<(), Report> {
    Ok(())
}

[samueltardieu]

@rustbot author

[rustbot]

Error: The "Author" shortcut only works on pull requests.

Please file an issue on GitHub at triagebot if there's a problem with this bot, or reach out on #t-infra on Zulip.

[teor2345]

@teor2345 Could you come up with a minimal reproducer? If you don't have the time to do this, I can start from an example that can be compiled if you have one.

I see the lint with:
https://github.com/ZcashFoundation/zebra/blob/ff54f8629681f1874c43c70bda370f519da214b1/zebra-consensus/src/primitives/redjubjub/tests.rs#L48-L65

I've tried copying that code into another project to reproduce the error, but even code like this doesn't reproduce it:

use std::{future, time::Duration};                                                                                                                                                                         
                                                                                                                                                                                                           
#[tokio::test]                                                                                                                                                                                             
async fn batch_flushes_on_max_items_test() -> color_eyre::Result<()> {                                                                                                                   
    batch_flushes_on_max_items().await                                                                                                                                                                     
}                                                                                                                                                                                                          
                                                                                                                                                                                                           
#[spandoc::spandoc]                                                                                                                                                                                        
async fn batch_flushes_on_max_items() -> color_eyre::Result<()> {                                                                                                                                          
    use tokio::time::timeout;                                                                                                                                                                              
                                                                                                                                                                                                           
    // Comment for spandoc                                                                                                                                                                                 
    timeout(                                                                                                                                                                                               
        Duration::from_secs(5),                                                                                                                                                                            
        future::pending::<Result<(), String>>(),                                                                                                                                                           
    )                                                                                                                                                                                                      
    .await?                                                                                                                                                                                                
    .map_err(|e| color_eyre::eyre::eyre!(e))?;                                                                                                                                                     
                                                                                                                                                                                                           
    Ok(())                                                                                                                                                                                                 
}

As an example, using the following in a test does not trigger the test, because Clippy ignore the macro output:

Does it help to use cargo clippy --tests or cargo clippy --all-targets?

[samueltardieu]

@teor2345 Could you come up with a minimal reproducer? If you don't have the time to do this, I can start from an example that can be compiled if you have one.

I see the lint with: https://github.com/ZcashFoundation/zebra/blob/ff54f8629681f1874c43c70bda370f519da214b1/zebra-consensus/src/primitives/redjubjub/tests.rs#L48-L65

Ok, I can reproduce this.

I've tried copying that code into another project to reproduce the error, but even code like this doesn't reproduce it:

Yes, at this point building a minimal reproducer is not trivial.

As an example, using the following in a test does not trigger the test, because Clippy ignore the macro output:

Does it help to use cargo clippy --tests or cargo clippy --all-targets?

That's what I was using.

Anyway, now that 3497086 has been merged, this lint will no longer trigger as soon as clippy and rustc sources are synchronized (first because it has been moved into the nursery category which is not active by default, second because it does not trigger on this kind of expression).

However, please keep this issue open as the underlying bug is still present: it can be reproduced by adding a qualified path (such as self::batch_flushed_on_max_items().await), and I'd like to fix it properly.

[samueltardieu]

Note: To check for this bug:

• Checkout zebra at version 6d0ce112dbd164954d9ef42d262f74ee23355748
• In Clippy sources, run cargo dev lint /path/to/zebra -- --all --all-targets -- -A clippy::all -D clippy::redundant_async_block