Clippy lint · Pedantic · checked with Clippy 0.1.99

clippy::unused_async_trait_impl: unused `async` for async trait impl function with no `.await` statements

What it meansChecks for trait method implementations that are declared async but have no .awaits inside of them. It is in the pedantic group and off by default.

What you see

warning: unused `async` for async trait impl function with no `.await` statements
  --> main.rs:8:5
   |
 8 | /     async fn get_random_number() -> i64 {
 9 | |         4 // Chosen by fair dice roll. Guaranteed to be random.
10 | |     }
   | |_____^
   |
   = note: `std::future::ready` creates a `Future` which returns the value immediately when `poll`ed
   = help: for further information visit https://rust-lang.github.io/rust-clippy/stable/index.html#unused_async_trait_impl
   = note: `-W clippy::unused-async-trait-impl` implied by `-W clippy::pedantic`
help: consider removing the `async` from this function and returning `impl Future<Output = i64>` instead
   |
 8 ~     fn get_random_number() -> impl Future<Output = i64> {
 9 ~         std::future::ready(4) // Chosen by fair dice roll. Guaranteed to be random.
   |

Real output of Clippy 0.1.99 (Rust 1.99) on the example below. Names and line numbers in yours will differ.

Does it matter?

Async functions with no async code create computational overhead. Even though the trait requires the method to return a future, returning a core::future::ready with the result is more efficient as it reduces the number of states in the Future state machine by at least one. Note that the behaviour is slightly different when using core::future::ready, as the value is computed immediately and stored in a future for later retrieval at the first (and only valid) call to poll. An async block generates code that completely defers the computation of this value until the Future is polled.

Stricter lints with some false positives. Off by default; opt in with clippy::pedantic.

How to fix it

Clippy does not fix this one automatically (its suggestion may change behaviour, so it only shows it). Change the code by hand:

Flagged

trait AsyncTrait {
    async fn get_random_number() -> i64;
}

impl AsyncTrait for () {
    async fn get_random_number() -> i64 {
        4 // Chosen by fair dice roll. Guaranteed to be random.
    }
}

Write this instead

trait AsyncTrait {
    async fn get_random_number() -> i64;
}

impl AsyncTrait for () {
    fn get_random_number() -> impl Future<Output = i64> {
        core::future::ready(4) // Chosen by fair dice roll. Guaranteed to be random.
    }
}

Turn it off, or on

It is off by default. To use it, set it to warn or deny:

Whole crate (Cargo.toml)

[lints.clippy]
unused_async_trait_impl = "warn"

In code

#![warn(clippy::unused_async_trait_impl)]

One run

cargo clippy -- -W clippy::unused-async-trait-impl

The [lints] table needs Rust 1.74 or newer. In a workspace, put it under [workspace.lints.clippy] and add [lints] workspace = true to each member.

Pedanticgroup

allowdefault level

nofixed by cargo clippy --fix

1.98.0added in Rust

Clippy's own documentation

What it does

Checks for trait method implementations that are declared async but have no .awaits inside of them.

Why is this bad?

Async functions with no async code create computational overhead. Even though the trait requires the method to return a future, returning a core::future::ready with the result is more efficient as it reduces the number of states in the Future state machine by at least one.

Note that the behaviour is slightly different when using core::future::ready, as the value is computed immediately and stored in a future for later retrieval at the first (and only valid) call to poll. An async block generates code that completely defers the computation of this value until the Future is polled.

Example

trait AsyncTrait {
    async fn get_random_number() -> i64;
}

impl AsyncTrait for () {
    async fn get_random_number() -> i64 {
        4 // Chosen by fair dice roll. Guaranteed to be random.
    }
}

Use instead:

trait AsyncTrait {
    async fn get_random_number() -> i64;
}

impl AsyncTrait for () {
    fn get_random_number() -> impl Future<Output = i64> {
        core::future::ready(4) // Chosen by fair dice roll. Guaranteed to be random.
    }
}

From the Clippy lint list (0.1.99), part of the Rust project, MIT or Apache-2.0. Official entry.

Up next

Also worth your time

Did this answer your question?