segmentation fault when using async_drop feature

[Sherlock-Holo]

I tried this code:

lib.rs

#![feature(async_drop)]

use std::future::AsyncDrop;
use std::pin::Pin;
use std::time::Duration;

use tokio::time;

pub async fn run() {
    let _st = St(Duration::from_secs(1));
}

pub struct St(Duration);

impl Drop for St {
    fn drop(&mut self) {}
}

impl AsyncDrop for St {
    async fn drop(self: Pin<&mut Self>) {
        time::sleep(self.0).await;

        println!("async drop");
    }
}

main.rs

#[tokio::main]
async fn main() {
    ttt::run().await;
}

Cargo.toml

[package]
name = "ttt"
version = "0.1.0"
edition = "2024"

[dependencies]
tokio = { version = "1.45.1", features = ["rt", "macros", "time", "rt-multi-thread"] }

I expected to see this happen: exit with 0

Instead, this happened:

[1]    4076757 segmentation fault (core dumped)  ./target/debug/ttt

Meta

rustc --version --verbose:

rustc 1.89.0-nightly (586ad391f 2025-06-15)
binary: rustc
commit-hash: 586ad391f5ee4519acc7cae340e34673bae762b1
commit-date: 2025-06-15
host: x86_64-unknown-linux-gnu
release: 1.89.0-nightly
LLVM version: 20.1.5

Backtrace

<backtrace>

[theemathas]

Dependency-free reproducer:

main.rs

// Doesn't have `#![feature(async_drop)]`

use std::{
    pin::pin,
    task::{Context, Waker},
};

fn main() {
    let mut context = Context::from_waker(Waker::noop());
    let future = pin!(async { foo::run().await });
    // For some reason, putting this value into a variable is load-bearing.
    let _x = future.poll(&mut context);
}

lib.rs

#![feature(async_drop)]

use std::future::AsyncDrop;
use std::pin::Pin;

pub async fn run() {
    let _st = St;
}

struct St;

impl Drop for St {
    fn drop(&mut self) {}
}

impl AsyncDrop for St {
    async fn drop(self: Pin<&mut Self>) {
        // Removing this line makes the program panic "normally" (not abort).
        nothing().await;
    }
}

async fn nothing() {}

Output on my machine:

warning: the feature `async_drop` is incomplete and may not be safe to use and/or cause compiler crashes
 --> src/lib.rs:1:12
  |
1 | #![feature(async_drop)]
  |            ^^^^^^^^^^
  |
  = note: see issue #126482 <https://github.com/rust-lang/rust/issues/126482> for more information
  = note: `#[warn(incomplete_features)]` on by default

warning: `foo` (lib) generated 1 warning
   Compiling foo v0.1.0 (/Users/timch/foo)
warning: found async drop types in dependency `foo`, but async_drop feature is disabled for `foo`
 --> src/main.rs:3:1
  |
3 | use std::{
  | ^
  |
  = help: if async drop type will be dropped in a crate without `feature(async_drop)`, sync Drop will be used

warning: `foo` (bin "foo") generated 1 warning
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.09s
     Running `target/debug/foo`

thread 'main' panicked at /Users/timch/foo/src/lib.rs:6:20:
`async fn` resumed after async drop
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
fatal runtime error: failed to initiate panic, error 5, aborting
[1]    20698 abort      cargo run

$ rustc +nightly --version --verbose
rustc 1.89.0-nightly (45acf54ee 2025-06-16)
binary: rustc
commit-hash: 45acf54eea118ed27927282b5e0bfdcd80b7987c
commit-date: 2025-06-16
host: aarch64-apple-darwin
release: 1.89.0-nightly
LLVM version: 20.1.5