Remove the async_fn_in_trait lint

compiler-errors · compiler-errors · commit 31739fbbbbdb · 2025-03-12T20:17:42.000Z
diff --git a/compiler/rustc_lint/messages.ftl b/compiler/rustc_lint/messages.ftl
@@ -21,10 +21,6 @@ lint_associated_const_elided_lifetime = {$elided ->
     .suggestion = use the `'static` lifetime
     .note = cannot automatically infer `'static` because of other lifetimes in scope
 
-lint_async_fn_in_trait = use of `async fn` in public traits is discouraged as auto trait bounds cannot be specified
-    .note = you can suppress this lint if you plan to use the trait only in your own code, or do not care about auto traits like `Send` on the `Future`
-    .suggestion = you can alternatively desugar to a normal `fn` that returns `impl Future` and add any desired bounds such as `Send`, but these cannot be relaxed without a breaking API change
-
 lint_atomic_ordering_fence = memory fences cannot have `Relaxed` ordering
     .help = consider using ordering modes `Acquire`, `Release`, `AcqRel` or `SeqCst`
 
diff --git a/compiler/rustc_lint/src/async_fn_in_trait.rs b/compiler/rustc_lint/src/async_fn_in_trait.rs
diff --git a/compiler/rustc_lint/src/lib.rs b/compiler/rustc_lint/src/lib.rs
@@ -36,7 +36,6 @@
 // tidy-alphabetical-end
 
 mod async_closures;
-mod async_fn_in_trait;
 pub mod builtin;
 mod context;
 mod dangling;
@@ -82,7 +81,6 @@ mod unqualified_local_imports;
 mod unused;
 
 use async_closures::AsyncClosureUsage;
-use async_fn_in_trait::AsyncFnInTrait;
 use builtin::*;
 use dangling::*;
 use default_could_be_derived::DefaultCouldBeDerived;
@@ -238,7 +236,6 @@ late_lint_methods!(
             MissingDebugImplementations: MissingDebugImplementations,
             MissingDoc: MissingDoc,
             AsyncClosureUsage: AsyncClosureUsage,
-            AsyncFnInTrait: AsyncFnInTrait,
             NonLocalDefinitions: NonLocalDefinitions::default(),
             ImplTraitOvercaptures: ImplTraitOvercaptures,
             IfLetRescope: IfLetRescope::default(),
@@ -604,6 +601,11 @@ fn register_builtins(store: &mut LintStore) {
         "converted into hard error, see issue #127323 \
          <https://github.com/rust-lang/rust/issues/127323> for more information",
     );
+    store.register_removed(
+        "async_fn_in_trait",
+        "lint was relaxed since return-type notation is stabilized; \
+        see <TODO> for more information",
+    )
 }
 
 fn register_internals(store: &mut LintStore) {
diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
@@ -2100,20 +2100,6 @@ pub(crate) struct UnusedAllocationDiag;
 #[diag(lint_unused_allocation_mut)]
 pub(crate) struct UnusedAllocationMutDiag;
 
-pub(crate) struct AsyncFnInTraitDiag {
-    pub sugg: Option<Vec<(Span, String)>>,
-}
-
-impl<'a> LintDiagnostic<'a, ()> for AsyncFnInTraitDiag {
-    fn decorate_lint<'b>(self, diag: &'b mut Diag<'a, ()>) {
-        diag.primary_message(fluent::lint_async_fn_in_trait);
-        diag.note(fluent::lint_note);
-        if let Some(sugg) = self.sugg {
-            diag.multipart_suggestion(fluent::lint_suggestion, sugg, Applicability::MaybeIncorrect);
-        }
-    }
-}
-
 #[derive(LintDiagnostic)]
 #[diag(lint_unit_bindings)]
 pub(crate) struct UnitBindingsDiag {
diff --git a/tests/ui/async-await/in-trait/async-associated-types.rs b/tests/ui/async-await/in-trait/async-associated-types.rs
@@ -6,14 +6,12 @@ use std::fmt::Debug;
 trait MyTrait<'a, 'b, T> where Self: 'a, T: Debug + Sized + 'b {
     type MyAssoc;
 
-    #[allow(async_fn_in_trait)]
     async fn foo(&'a self, key: &'b T) -> Self::MyAssoc;
 }
 
 impl<'a, 'b, T: Debug + Sized + 'b, U: 'a> MyTrait<'a, 'b, T> for U {
     type MyAssoc = (&'a U, &'b T);
 
-    #[allow(async_fn_in_trait)]
     async fn foo(&'a self, key: &'b T) -> (&'a U, &'b T) {
         (self, key)
     }
diff --git a/tests/ui/async-await/in-trait/async-default-fn-overridden.rs b/tests/ui/async-await/in-trait/async-default-fn-overridden.rs
@@ -4,12 +4,10 @@
 use std::future::Future;
 
 trait AsyncTrait {
-    #[allow(async_fn_in_trait)]
     async fn default_impl() {
         assert!(false);
     }
 
-    #[allow(async_fn_in_trait)]
     async fn call_default_impl() {
         Self::default_impl().await
     }
diff --git a/tests/ui/async-await/in-trait/async-example-desugared-boxed.rs b/tests/ui/async-await/in-trait/async-example-desugared-boxed.rs
@@ -4,7 +4,6 @@
 use std::future::Future;
 use std::pin::Pin;
 
-#[allow(async_fn_in_trait)]
 pub trait MyTrait {
     async fn foo(&self) -> i32;
 }
diff --git a/tests/ui/async-await/in-trait/async-example-desugared-boxed.stderr b/tests/ui/async-await/in-trait/async-example-desugared-boxed.stderr
@@ -1,5 +1,5 @@
 warning: impl trait in impl method signature does not match trait method signature
-  --> $DIR/async-example-desugared-boxed.rs:14:22
+  --> $DIR/async-example-desugared-boxed.rs:13:22
    |
 LL |     async fn foo(&self) -> i32;
    |     --------------------------- return type from trait method defined here
@@ -10,7 +10,7 @@ LL |     fn foo(&self) -> Pin<Box<dyn Future<Output = i32> + '_>> {
    = note: add `#[allow(refining_impl_trait)]` if it is intended for this to be part of the public API of this crate
    = note: we are soliciting feedback, see issue #121718 <https://github.com/rust-lang/rust/issues/121718> for more information
 note: the lint level is defined here
-  --> $DIR/async-example-desugared-boxed.rs:13:12
+  --> $DIR/async-example-desugared-boxed.rs:12:12
    |
 LL |     #[warn(refining_impl_trait)]
    |            ^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/async-await/in-trait/async-example-desugared-extra.rs b/tests/ui/async-await/in-trait/async-example-desugared-extra.rs
@@ -6,7 +6,6 @@ use std::pin::Pin;
 use std::task::Poll;
 
 pub trait MyTrait {
-    #[allow(async_fn_in_trait)]
     async fn foo(&self) -> i32;
 }
 
diff --git a/tests/ui/async-await/in-trait/async-example-desugared-manual.rs b/tests/ui/async-await/in-trait/async-example-desugared-manual.rs
@@ -4,7 +4,6 @@
 use std::future::Future;
 use std::task::Poll;
 
-#[allow(async_fn_in_trait)]
 pub trait MyTrait {
     async fn foo(&self) -> i32;
 }
diff --git a/tests/ui/async-await/in-trait/async-example-desugared-manual.stderr b/tests/ui/async-await/in-trait/async-example-desugared-manual.stderr
@@ -1,5 +1,5 @@
 warning: impl trait in impl method signature does not match trait method signature
-  --> $DIR/async-example-desugared-manual.rs:22:22
+  --> $DIR/async-example-desugared-manual.rs:21:22
    |
 LL |     async fn foo(&self) -> i32;
    |     --------------------------- return type from trait method defined here
@@ -10,7 +10,7 @@ LL |     fn foo(&self) -> MyFuture {
    = note: add `#[allow(refining_impl_trait)]` if it is intended for this to be part of the public API of this crate
    = note: we are soliciting feedback, see issue #121718 <https://github.com/rust-lang/rust/issues/121718> for more information
 note: the lint level is defined here
-  --> $DIR/async-example-desugared-manual.rs:21:12
+  --> $DIR/async-example-desugared-manual.rs:20:12
    |
 LL |     #[warn(refining_impl_trait)]
    |            ^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/async-await/in-trait/async-example-desugared.rs b/tests/ui/async-await/in-trait/async-example-desugared.rs
@@ -4,7 +4,6 @@
 use std::future::Future;
 
 trait MyTrait {
-    #[allow(async_fn_in_trait)]
     async fn foo(&self) -> i32;
 }
 
diff --git a/tests/ui/async-await/in-trait/async-example.rs b/tests/ui/async-await/in-trait/async-example.rs
@@ -2,10 +2,8 @@
 //@ edition: 2021
 
 trait MyTrait {
-    #[allow(async_fn_in_trait)]
     async fn foo(&self) -> i32;
 
-    #[allow(async_fn_in_trait)]
     async fn bar(&self) -> i32;
 }
 
diff --git a/tests/ui/async-await/in-trait/async-lifetimes-and-bounds.rs b/tests/ui/async-await/in-trait/async-lifetimes-and-bounds.rs
@@ -4,7 +4,6 @@
 use std::fmt::Debug;
 
 trait MyTrait<'a, 'b, T> {
-    #[allow(async_fn_in_trait)]
     async fn foo(&'a self, key: &'b T) -> (&'a Self, &'b T) where T: Debug + Sized;
 }
 
diff --git a/tests/ui/async-await/in-trait/async-lifetimes.rs b/tests/ui/async-await/in-trait/async-lifetimes.rs
@@ -2,7 +2,6 @@
 //@ edition: 2021
 
 trait MyTrait<'a, 'b, T> {
-    #[allow(async_fn_in_trait)]
     async fn foo(&'a self, key: &'b T) -> (&'a Self, &'b T);
 }
 
diff --git a/tests/ui/async-await/in-trait/auxiliary/bad-region.rs b/tests/ui/async-await/in-trait/auxiliary/bad-region.rs
@@ -1,7 +1,5 @@
 //@ edition:2021
 
-#[allow(async_fn_in_trait)]
-
 pub trait BleRadio<'a> {
     async fn transmit(&mut self);
 }
diff --git a/tests/ui/async-await/in-trait/bad-region.rs b/tests/ui/async-await/in-trait/bad-region.rs
@@ -1,8 +1,6 @@
 //@ aux-build:bad-region.rs
 //@ edition:2021
 
-#![allow(async_fn_in_trait)]
-
 extern crate bad_region as jewel;
 
 use jewel::BleRadio;
diff --git a/tests/ui/async-await/in-trait/bad-region.stderr b/tests/ui/async-await/in-trait/bad-region.stderr
@@ -1,5 +1,5 @@
 error[E0726]: implicit elided lifetime not allowed here
-  --> $DIR/bad-region.rs:12:6
+  --> $DIR/bad-region.rs:10:6
    |
 LL | impl BleRadio for Radio {
    |      ^^^^^^^^ expected lifetime parameter
diff --git a/tests/ui/async-await/in-trait/early-bound-1.rs b/tests/ui/async-await/in-trait/early-bound-1.rs
@@ -2,7 +2,6 @@
 //@ edition:2021
 
 pub trait Foo {
-    #[allow(async_fn_in_trait)]
     async fn foo(&mut self);
 }
 
diff --git a/tests/ui/async-await/in-trait/early-bound-2.rs b/tests/ui/async-await/in-trait/early-bound-2.rs
@@ -2,7 +2,6 @@
 //@ edition:2021
 
 pub trait Foo {
-    #[allow(async_fn_in_trait)]
     async fn foo(&mut self);
 }
 
diff --git a/tests/ui/async-await/in-trait/implied-bounds.rs b/tests/ui/async-await/in-trait/implied-bounds.rs
@@ -5,7 +5,6 @@ trait TcpStack {
     type Connection<'a>: Sized where Self: 'a;
     fn connect<'a>(&'a self) -> Self::Connection<'a>;
 
-    #[allow(async_fn_in_trait)]
     async fn async_connect<'a>(&'a self) -> Self::Connection<'a>;
 }
 
diff --git a/tests/ui/async-await/in-trait/issue-102138.rs b/tests/ui/async-await/in-trait/issue-102138.rs
@@ -8,7 +8,6 @@ async fn yield_now() {}
 trait AsyncIterator {
     type Item;
 
-    #[allow(async_fn_in_trait)]
     async fn next(&mut self) -> Option<Self::Item>;
 }
 
diff --git a/tests/ui/async-await/in-trait/issue-102219.rs b/tests/ui/async-await/in-trait/issue-102219.rs
@@ -3,6 +3,5 @@
 //@ check-pass
 
 trait T {
-    #[allow(async_fn_in_trait)]
     async fn foo();
 }
diff --git a/tests/ui/async-await/in-trait/issue-102310.rs b/tests/ui/async-await/in-trait/issue-102310.rs
@@ -2,7 +2,6 @@
 //@ edition:2021
 
 pub trait SpiDevice {
-    #[allow(async_fn_in_trait)]
     async fn transaction<F, R>(&mut self);
 }
 
diff --git a/tests/ui/async-await/in-trait/issue-104678.rs b/tests/ui/async-await/in-trait/issue-104678.rs
@@ -5,7 +5,6 @@ use std::future::Future;
 pub trait Pool {
     type Conn;
 
-    #[allow(async_fn_in_trait)]
     async fn async_callback<'a, F: FnOnce(&'a Self::Conn) -> Fut, Fut: Future<Output = ()>>(
         &'a self,
         callback: F,
diff --git a/tests/ui/async-await/in-trait/nested-rpit.rs b/tests/ui/async-await/in-trait/nested-rpit.rs
diff --git a/tests/ui/async-await/in-trait/normalize-opaque-with-bound-vars.rs b/tests/ui/async-await/in-trait/normalize-opaque-with-bound-vars.rs
diff --git a/tests/ui/impl-trait/in-trait/assumed-wf-bounds-in-impl.rs b/tests/ui/impl-trait/in-trait/assumed-wf-bounds-in-impl.rs
diff --git a/tests/ui/impl-trait/in-trait/default-body-with-rpit.rs b/tests/ui/impl-trait/in-trait/default-body-with-rpit.rs
diff --git a/tests/ui/impl-trait/in-trait/default-body.rs b/tests/ui/impl-trait/in-trait/default-body.rs
diff --git a/tests/ui/impl-trait/in-trait/early.rs b/tests/ui/impl-trait/in-trait/early.rs
diff --git a/tests/ui/impl-trait/in-trait/suggest-missing-item.fixed b/tests/ui/impl-trait/in-trait/suggest-missing-item.fixed
diff --git a/tests/ui/impl-trait/in-trait/suggest-missing-item.rs b/tests/ui/impl-trait/in-trait/suggest-missing-item.rs
diff --git a/tests/ui/impl-trait/in-trait/suggest-missing-item.stderr b/tests/ui/impl-trait/in-trait/suggest-missing-item.stderr

Original file line number	Diff line number	Diff line change
`@@ -6,14 +6,12 @@ use std::fmt::Debug;`
`6`	`6`	`trait MyTrait<'a, 'b, T> where Self: 'a, T: Debug + Sized + 'b {`
`7`	`7`	`type MyAssoc;`
`8`	`8`
`9`		`- #[allow(async_fn_in_trait)]`
`10`	`9`	`async fn foo(&'a self, key: &'b T) -> Self::MyAssoc;`
`11`	`10`	`}`
`12`	`11`
`13`	`12`	`impl<'a, 'b, T: Debug + Sized + 'b, U: 'a> MyTrait<'a, 'b, T> for U {`
`14`	`13`	`type MyAssoc = (&'a U, &'b T);`
`15`	`14`
`16`		`- #[allow(async_fn_in_trait)]`
`17`	`15`	`async fn foo(&'a self, key: &'b T) -> (&'a U, &'b T) {`
`18`	`16`	`(self, key)`
`19`	`17`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,12 +4,10 @@`
`4`	`4`	`use std::future::Future;`
`5`	`5`
`6`	`6`	`trait AsyncTrait {`
`7`		`- #[allow(async_fn_in_trait)]`
`8`	`7`	`async fn default_impl() {`
`9`	`8`	`assert!(false);`
`10`	`9`	`}`
`11`	`10`
`12`		`- #[allow(async_fn_in_trait)]`
`13`	`11`	`async fn call_default_impl() {`
`14`	`12`	`Self::default_impl().await`
`15`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,6 @@`
`4`	`4`	`use std::future::Future;`
`5`	`5`	`use std::pin::Pin;`
`6`	`6`
`7`		`-#[allow(async_fn_in_trait)]`
`8`	`7`	`pub trait MyTrait {`
`9`	`8`	`async fn foo(&self) -> i32;`
`10`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,6 @@ use std::pin::Pin;`
`6`	`6`	`use std::task::Poll;`
`7`	`7`
`8`	`8`	`pub trait MyTrait {`
`9`		`- #[allow(async_fn_in_trait)]`
`10`	`9`	`async fn foo(&self) -> i32;`
`11`	`10`	`}`
`12`	`11`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,6 @@`
`4`	`4`	`use std::future::Future;`
`5`	`5`
`6`	`6`	`trait MyTrait {`
`7`		`- #[allow(async_fn_in_trait)]`
`8`	`7`	`async fn foo(&self) -> i32;`
`9`	`8`	`}`
`10`	`9`
Original file line number	Diff line number	Diff line change
`@@ -2,10 +2,8 @@`
`2`	`2`	`//@ edition: 2021`
`3`	`3`
`4`	`4`	`trait MyTrait {`
`5`		`- #[allow(async_fn_in_trait)]`
`6`	`5`	`async fn foo(&self) -> i32;`
`7`	`6`
`8`		`- #[allow(async_fn_in_trait)]`
`9`	`7`	`async fn bar(&self) -> i32;`
`10`	`8`	`}`
`11`	`9`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,6 @@`
`4`	`4`	`use std::fmt::Debug;`
`5`	`5`
`6`	`6`	`trait MyTrait<'a, 'b, T> {`
`7`		`- #[allow(async_fn_in_trait)]`
`8`	`7`	`async fn foo(&'a self, key: &'b T) -> (&'a Self, &'b T) where T: Debug + Sized;`
`9`	`8`	`}`
`10`	`9`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,6 @@`
`2`	`2`	`//@ edition: 2021`
`3`	`3`
`4`	`4`	`trait MyTrait<'a, 'b, T> {`
`5`		`- #[allow(async_fn_in_trait)]`
`6`	`5`	`async fn foo(&'a self, key: &'b T) -> (&'a Self, &'b T);`
`7`	`6`	`}`
`8`	`7`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,5 @@`
`1`	`1`	`//@ edition:2021`
`2`	`2`
`3`		`-#[allow(async_fn_in_trait)]`
`4`		`-`
`5`	`3`	`pub trait BleRadio<'a> {`
`6`	`4`	`async fn transmit(&mut self);`
`7`	`5`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`error[E0726]: implicit elided lifetime not allowed here`
`2`		`- --> $DIR/bad-region.rs:12:6`
	`2`	`+ --> $DIR/bad-region.rs:10:6`
`3`	`3`	`\|`
`4`	`4`	`LL \| impl BleRadio for Radio {`
`5`	`5`	`\| ^^^^^^^^ expected lifetime parameter`