(BLOCKED) Stabilize async_fn_track_caller

compiler/rustc_ast_lowering/src/expr.rs

@@ -881,15 +881,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     /// Forwards a possible `#[track_caller]` annotation from `outer_hir_id` to
-    /// `inner_hir_id` in case the `async_fn_track_caller` feature is enabled.
+    /// `inner_hir_id`.
     pub(super) fn maybe_forward_track_caller(
         &mut self,
         span: Span,
         outer_hir_id: HirId,
         inner_hir_id: HirId,
     ) {
-        if self.tcx.features().async_fn_track_caller()
-            && let Some(attrs) = self.attrs.get(&outer_hir_id.local_id)
+        if let Some(attrs) = self.attrs.get(&outer_hir_id.local_id)
             && find_attr!(*attrs, TrackCaller(_))
         {
             let unstable_span = self.mark_span_with_reason(

compiler/rustc_ast_lowering/src/item.rs

@@ -1460,7 +1460,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 hir::CoroutineSource::Fn,
             );
 
-            // FIXME(async_fn_track_caller): Can this be moved above?
             let hir_id = expr.hir_id;
             this.maybe_forward_track_caller(body.span, fn_id, hir_id);
 

compiler/rustc_ast_lowering/src/lib.rs

@@ -276,11 +276,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             ]
             .into(),
             allow_pattern_type: [sym::pattern_types, sym::pattern_type_range_trait].into(),
-            allow_gen_future: if tcx.features().async_fn_track_caller() {
-                [sym::gen_future, sym::closure_track_caller].into()
-            } else {
-                [sym::gen_future].into()
-            },
+            allow_gen_future: [sym::gen_future, sym::closure_track_caller].into(),
             allow_for_await: [sym::async_gen_internals, sym::async_iterator].into(),
             allow_async_fn_traits: [sym::async_fn_traits].into(),
             allow_async_gen: [sym::async_gen_internals].into(),

compiler/rustc_feature/src/accepted.rs

@@ -79,6 +79,8 @@ declare_features! (
     (accepted, async_closure, "1.85.0", Some(62290)),
     /// Allows async functions to be declared, implemented, and used in traits.
     (accepted, async_fn_in_trait, "1.75.0", Some(91611)),
+    /// Allows `#[track_caller]` on async functions.
+    (accepted, async_fn_track_caller, "CURRENT_RUSTC_VERSION", Some(110011)),
     /// Allows all literals in attribute lists and values of key-value pairs.
     (accepted, attr_literals, "1.30.0", Some(34981)),
     /// Allows overloading augmented assignment operations like `a += b`.

compiler/rustc_feature/src/unstable.rs

@@ -410,8 +410,6 @@ declare_features! (
     (incomplete, async_drop, "1.88.0", Some(126482)),
     /// Allows async functions to be called from `dyn Trait`.
     (incomplete, async_fn_in_dyn_trait, "1.85.0", Some(133119)),
-    /// Allows `#[track_caller]` on async functions.
-    (unstable, async_fn_track_caller, "1.73.0", Some(110011)),
     /// Allows `for await` loops.
     (unstable, async_for_loop, "1.77.0", Some(118898)),
     /// Allows `async` trait bound modifier.

compiler/rustc_lint/src/builtin.rs

@@ -28,8 +28,7 @@ use rustc_hir::attrs::lang_items::LangItem;
 use rustc_hir::attrs::{AttributeKind, DocAttribute};
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{CRATE_DEF_ID, DefId, LocalDefId};
-use rustc_hir::intravisit::FnKind as HirFnKind;
-use rustc_hir::{self as hir, Body, FnDecl, ImplItemImplKind, PatKind, PredicateOrigin, find_attr};
+use rustc_hir::{self as hir, ImplItemImplKind, PatKind, PredicateOrigin, find_attr};
 // Lints from rustc_lint_defs
 pub use rustc_lint_defs::builtin::*;
 use rustc_lint_defs::{declare_lint, declare_lint_pass, fcw, impl_lint_pass};
@@ -55,10 +54,9 @@ use crate::diagnostics::{
     BuiltinIncompleteFeaturesHelp, BuiltinInternalFeatures, BuiltinKeywordIdents,
     BuiltinMissingCopyImpl, BuiltinMissingDebugImpl, BuiltinMissingDoc, BuiltinMutablesTransmutes,
     BuiltinNonShorthandFieldPatterns, BuiltinSpecialModuleNameUsed, BuiltinTrivialBounds,
-    BuiltinTypeAliasBounds, BuiltinUngatedAsyncFnTrackCaller, BuiltinUnpermittedTypeInit,
-    BuiltinUnpermittedTypeInitSub, BuiltinUnreachablePub, BuiltinUnsafe, BuiltinUnstableFeatures,
-    BuiltinUnusedDocComment, BuiltinUnusedDocCommentSub, BuiltinWhileTrue,
-    EqInternalMethodImplemented, InvalidAsmLabel,
+    BuiltinTypeAliasBounds, BuiltinUnpermittedTypeInit, BuiltinUnpermittedTypeInitSub,
+    BuiltinUnreachablePub, BuiltinUnsafe, BuiltinUnstableFeatures, BuiltinUnusedDocComment,
+    BuiltinUnusedDocCommentSub, BuiltinWhileTrue, EqInternalMethodImplemented, InvalidAsmLabel,
 };
 use crate::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
 
@@ -1042,62 +1040,6 @@ impl<'tcx> LateLintPass<'tcx> for UnstableFeatures {
     }
 }
 
-declare_lint! {
-    /// The `ungated_async_fn_track_caller` lint warns when the
-    /// `#[track_caller]` attribute is used on an async function
-    /// without enabling the corresponding unstable feature flag.
-    ///
-    /// ### Example
-    ///
-    /// ```rust
-    /// #[track_caller]
-    /// async fn foo() {}
-    /// ```
-    ///
-    /// {{produces}}
-    ///
-    /// ### Explanation
-    ///
-    /// The attribute must be used in conjunction with the
-    /// [`async_fn_track_caller` feature flag]. Otherwise, the `#[track_caller]`
-    /// annotation will function as a no-op.
-    ///
-    /// [`async_fn_track_caller` feature flag]: https://doc.rust-lang.org/beta/unstable-book/language-features/async-fn-track-caller.html
-    UNGATED_ASYNC_FN_TRACK_CALLER,
-    Warn,
-    "enabling track_caller on an async fn is a no-op unless the async_fn_track_caller feature is enabled"
-}
-
-declare_lint_pass!(
-    /// Explains corresponding feature flag must be enabled for the `#[track_caller]` attribute to
-    /// do anything
-    UngatedAsyncFnTrackCaller => [UNGATED_ASYNC_FN_TRACK_CALLER]
-);
-
-impl<'tcx> LateLintPass<'tcx> for UngatedAsyncFnTrackCaller {
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'_>,
-        fn_kind: HirFnKind<'_>,
-        _: &'tcx FnDecl<'_>,
-        _: &'tcx Body<'_>,
-        span: Span,
-        def_id: LocalDefId,
-    ) {
-        if fn_kind.asyncness().is_async()
-            && !cx.tcx.features().async_fn_track_caller()
-            // Now, check if the function has the `#[track_caller]` attribute
-            && let Some(attr_span) = find_attr!(cx.tcx, def_id, TrackCaller(span) => *span)
-        {
-            cx.emit_span_lint(
-                UNGATED_ASYNC_FN_TRACK_CALLER,
-                attr_span,
-                BuiltinUngatedAsyncFnTrackCaller { label: span, session: &cx.tcx.sess },
-            );
-        }
-    }
-}
-
 declare_lint! {
     /// The `unreachable_pub` lint triggers for `pub` items not reachable from other crates - that
     /// means neither directly accessible, nor reexported (with `pub use`), nor leaked through

compiler/rustc_lint/src/diagnostics.rs

@@ -14,9 +14,8 @@ use rustc_hir::intravisit::VisitorExt;
 use rustc_macros::{Diagnostic, Subdiagnostic};
 use rustc_middle::ty::inhabitedness::InhabitedPredicate;
 use rustc_middle::ty::{Clause, PolyExistentialTraitRef, Ty, TyCtxt};
-use rustc_session::Session;
 use rustc_span::edition::Edition;
-use rustc_span::{Ident, Span, Symbol, sym};
+use rustc_span::{Ident, Span, Symbol};
 
 use crate::LateContext;
 use crate::builtin::{InitError, ShorthandAssocTyCollector, TypeAliasBounds};
@@ -362,25 +361,6 @@ pub(crate) struct BuiltinMutablesTransmutes;
 #[diag("use of an unstable feature")]
 pub(crate) struct BuiltinUnstableFeatures;
 
-// lint_ungated_async_fn_track_caller
-pub(crate) struct BuiltinUngatedAsyncFnTrackCaller<'a> {
-    pub label: Span,
-    pub session: &'a Session,
-}
-
-impl<'a> Diagnostic<'a, ()> for BuiltinUngatedAsyncFnTrackCaller<'_> {
-    fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
-        let mut diag = Diag::new(dcx, level, "`#[track_caller]` on async functions is a no-op")
-            .with_span_label(self.label, "this function will not propagate the caller location");
-        rustc_session::diagnostics::add_feature_diagnostics(
-            &mut diag,
-            self.session,
-            sym::async_fn_track_caller,
-        );
-        diag
-    }
-}
-
 #[derive(Diagnostic)]
 #[diag("unreachable `pub` {$what}")]
 pub(crate) struct BuiltinUnreachablePub<'a> {

compiler/rustc_lint/src/lib.rs

@@ -273,7 +273,6 @@ late_lint_methods!(
             TrivialConstraints: TrivialConstraints,
             TypeAliasBounds: TypeAliasBounds,
             TypeLimits: TypeLimits::new(),
-            UngatedAsyncFnTrackCaller: UngatedAsyncFnTrackCaller,
             UnitBindings: UnitBindings,
             UnqualifiedLocalImports: UnqualifiedLocalImports,
             // Depends on effective visibilities
@@ -718,6 +717,11 @@ fn register_builtins(store: &mut LintStore) {
         "dependency_on_unit_never_type_fallback",
         "the code warned by this lint no longer compiles",
     );
+    store.register_removed(
+        "ungated_async_fn_track_caller",
+        "the `async_fn_track_caller` feature has stabilized, see \
+         <https://github.com/rust-lang/rust/issues/110011> for more information",
+    );
 }
 
 fn register_internals(store: &mut LintStore) {

tests/ui/async-await/track-caller/async-block.nofeat.stderr

@@ -1,27 +1,27 @@
 error[E0658]: `#[track_caller]` on closures is currently unstable
-  --> $DIR/async-block.rs:8:13
+  --> $DIR/async-block.rs:9:13
    |
-LL |     let _ = #[track_caller] async {
+LL |     let _ = #[track_caller]
    |             ^^^^^^^^^^^^^^^
    |
    = note: see issue #87417 <https://github.com/rust-lang/rust/issues/87417> for more information
    = help: add `#![feature(closure_track_caller)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: `#[track_caller]` on closures is currently unstable
-  --> $DIR/async-block.rs:15:13
+  --> $DIR/async-block.rs:16:13
    |
-LL |     let _ = #[track_caller] async {
+LL |     let _ = #[track_caller]
    |             ^^^^^^^^^^^^^^^
    |
    = note: see issue #87417 <https://github.com/rust-lang/rust/issues/87417> for more information
    = help: add `#![feature(closure_track_caller)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: `#[track_caller]` on closures is currently unstable
-  --> $DIR/async-block.rs:23:17
+  --> $DIR/async-block.rs:24:17
    |
-LL |         let _ = #[track_caller] async {
+LL |         let _ = #[track_caller]
    |                 ^^^^^^^^^^^^^^^
    |
    = note: see issue #87417 <https://github.com/rust-lang/rust/issues/87417> for more information

tests/ui/async-await/track-caller/async-block.rs

@@ -1,27 +1,28 @@
 //@ edition:2021
-//@ revisions: afn nofeat
+//@ revisions: cls nofeat
+//@[cls] check-pass
 
 #![feature(stmt_expr_attributes)]
-#![cfg_attr(afn, feature(async_fn_track_caller))]
+#![cfg_attr(cls, feature(closure_track_caller))]
 
 fn main() {
-    let _ = #[track_caller] async {
-        //~^ ERROR `#[track_caller]` on closures is currently unstable [E0658]
-    };
+    let _ = #[track_caller]
+    //[nofeat]~^ ERROR `#[track_caller]` on closures is currently unstable [E0658]
+    async {};
 }
 
 #[track_caller]
 async fn foo() {
-    let _ = #[track_caller] async {
-        //~^ ERROR `#[track_caller]` on closures is currently unstable [E0658]
-    };
+    let _ = #[track_caller]
+    //[nofeat]~^ ERROR `#[track_caller]` on closures is currently unstable [E0658]
+    async {};
 }
 
 #[track_caller]
 async fn foo2() {
     let _ = async {
-        let _ = #[track_caller] async {
-            //~^ ERROR `#[track_caller]` on closures is currently unstable [E0658]
-        };
+        let _ = #[track_caller]
+        //[nofeat]~^ ERROR `#[track_caller]` on closures is currently unstable [E0658]
+        async {};
     };
 }