From d560d3a480edb3d3f39b7d4a6343c6765b153baa Mon Sep 17 00:00:00 2001
From: Sander Saares <sander@saares.eu>
Date: Thu, 26 Mar 2026 09:13:54 +0800
Subject: [PATCH] Add test for async Send inference with PhantomData<*mut ()> +
 unsafe impl Send + dyn Trait

Add a regression test covering the case where a type uses
PhantomData<*mut ()> to opt out of Sync, restores Send via an unsafe
impl, and is then captured across an .await point with a trait object
type parameter (Box<dyn Trait>).

The compiler currently erases lifetimes in MIR coroutine witnesses,
losing the 'static bound needed to apply the unsafe impl Send. The
test verifies this is fixed by -Zhigher-ranked-assumptions and
documents the PhantomData<Cell<()>> workaround as a comparison. See
the PR description for links to the relevant issues.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 ...ranked-auto-trait-18.no_assumptions.stderr | 13 +++
 .../higher-ranked-auto-trait-18.rs            | 79 +++++++++++++++++++
 2 files changed, 92 insertions(+)
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-18.no_assumptions.stderr
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-18.rs

diff --git a/tests/ui/async-await/higher-ranked-auto-trait-18.no_assumptions.stderr b/tests/ui/async-await/higher-ranked-auto-trait-18.no_assumptions.stderr
new file mode 100644
index 0000000000000..5a4c99acd0d43
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-18.no_assumptions.stderr
@@ -0,0 +1,13 @@
+error: higher-ranked lifetime error
+  --> $DIR/higher-ranked-auto-trait-18.rs:69:5
+   |
+LL | /     require_send(async {
+LL | |         let r = Receiver::<Box<dyn MyTrait>> { _value: None, _not_sync: PhantomData };
+LL | |         let _ = r.await;
+LL | |     });
+   | |______^
+   |
+   = note: could not prove `{async block@$DIR/higher-ranked-auto-trait-18.rs:69:18: 69:23}: Send`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-18.rs b/tests/ui/async-await/higher-ranked-auto-trait-18.rs
new file mode 100644
index 0000000000000..3839fd86cfeba
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-18.rs
@@ -0,0 +1,79 @@
+// Repro for a bug where `PhantomData<*mut ()>` + `unsafe impl Send` fails to prove
+// `Send` for an async block when the type parameter is a trait object (`dyn Trait`).
+//
+// The static assertion `assert_send::<Receiver<Box<dyn MyTrait>>>()` succeeds,
+// but the same type captured across an `.await` in an async block does not.
+// This is because MIR erases the `'static` lifetime from `dyn MyTrait + 'static`,
+// and the auto-trait analysis cannot recover the `T: 'static` bound without
+// higher-ranked assumptions.
+//
+// Using `PhantomData<Cell<()>>` instead of `PhantomData<*mut ()>` avoids the
+// issue because `Cell<()>` is natively `Send`, so no `unsafe impl` (with its
+// `T: 'static` bound) is needed.
+//
+// See <https://github.com/rust-lang/rust/issues/110338>.
+//@ edition: 2021
+//@ revisions: assumptions no_assumptions
+//@[assumptions] compile-flags: -Zhigher-ranked-assumptions
+//@[assumptions] check-pass
+//@[no_assumptions] known-bug: #110338
+
+use std::cell::Cell;
+use std::future::Future;
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+// --- PhantomData<*mut ()> version: needs `unsafe impl Send` ---
+
+struct Receiver<T: Send + 'static> {
+    _value: Option<T>,
+    _not_sync: PhantomData<*mut ()>,
+}
+
+unsafe impl<T: Send + 'static> Send for Receiver<T> {}
+
+impl<T: Send + 'static> Future for Receiver<T> {
+    type Output = T;
+    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Poll::Pending
+    }
+}
+
+// --- PhantomData<Cell<()>> version: auto-derived Send works ---
+
+struct ReceiverCell<T: Send + 'static> {
+    _value: Option<T>,
+    _not_sync: PhantomData<Cell<()>>,
+}
+
+impl<T: Send + 'static> Future for ReceiverCell<T> {
+    type Output = T;
+    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Poll::Pending
+    }
+}
+
+trait MyTrait: Send {}
+
+fn require_send<F: Future + Send>(_f: F) {}
+
+fn main() {
+    // PhantomData<*mut ()> + concrete type: always works.
+    require_send(async {
+        let r = Receiver::<u32> { _value: None, _not_sync: PhantomData };
+        let _ = r.await;
+    });
+
+    // PhantomData<*mut ()> + dyn Trait: fails without higher-ranked assumptions.
+    require_send(async {
+        let r = Receiver::<Box<dyn MyTrait>> { _value: None, _not_sync: PhantomData };
+        let _ = r.await;
+    });
+
+    // PhantomData<Cell<()>> + dyn Trait: always works (auto-derived Send).
+    require_send(async {
+        let r = ReceiverCell::<Box<dyn MyTrait>> { _value: None, _not_sync: PhantomData };
+        let _ = r.await;
+    });
+}