Clippy lint · Suspicious · checked with Clippy 0.1.99

clippy::await_holding_invalid_type: Allows users to configure types which should not be held across await suspension points

What it meansAllows users to configure types which should not be held across await suspension points. It is in the suspicious group and warns by default.

Does it matter?

There are some types which are perfectly safe to use concurrently from a memory access perspective, but that will cause bugs at runtime if they are held in such a way.

Code that is most likely wrong or useless. Warns by default.

How to fix it

Clippy does not fix this one automatically. Change the code by hand:

Flagged

struct CustomLockType;
struct OtherCustomLockType;
async fn foo() {
  let _x = CustomLockType;
  let _y = OtherCustomLockType;
  baz().await; // Lint violation
}

Turn it off, or on

Allow it where it does not fit your code, as narrowly as you can:

On one item

#[allow(clippy::await_holding_invalid_type)]
fn my_function() { /* ... */ }

Whole crate (Cargo.toml)

[lints.clippy]
await_holding_invalid_type = "allow"

One run

cargo clippy -- -A clippy::await-holding-invalid-type

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.

Settings in clippy.toml

await-holding-invalid-types: The list of types which may not be held across an await point.

Suspiciousgroup

warndefault level

nofixed by cargo clippy --fix

1.62.0added in Rust

Clippy's own documentation

What it does

Allows users to configure types which should not be held across await suspension points.

Why is this bad?

There are some types which are perfectly safe to use concurrently from a memory access perspective, but that will cause bugs at runtime if they are held in such a way.

Example

await-holding-invalid-types = [
  # You can specify a type name
  "CustomLockType",
  # You can (optionally) specify a reason
  { path = "OtherCustomLockType", reason = "Relies on a thread local" }
]

struct CustomLockType;
struct OtherCustomLockType;
async fn foo() {
  let _x = CustomLockType;
  let _y = OtherCustomLockType;
  baz().await; // Lint violation
}

Configuration

await-holding-invalid-types: The list of types which may not be held across an await point.

(default: [])

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?