1.93 regression satisfying send obligation

[conradludgate]

I cannot share a reproduction right at this moment (closed source), I will work to minimise the error sometime soon. I will describe the error that I am seeing though, incase someone can figure out a minimum repro by the error and regression alone.

• With 1.92, my code compiles.
• With 1.93 dev profile, my code compiles.
• With 1.93 release profile, my code no longer compiles.
• With 1.93 release and debug-assertions, my code still doesn't compile.

I see the following (truncated) error:

error: cannot check whether the hidden type of opaque type satisfies auto traits
   --> proxy/src/pglb/local_proxy.rs:115:14
    |
115 |             .boxed()
    |              ^^^^^
    |
    = note: fetching the hidden types of an opaque inside of the defining scope is not supported. You can try moving the opaque type and the item that actually registers a hidden type into a new submodule
note: opaque type is declared here
   --> proxy/src/pqproto.rs:155:1
    |
155 | / pub async fn read_startup<S>(stream: &mut S) -> io::Result<FeStartupPacket>
156 | | where
157 | |     S: AsyncRead + Unpin,
    | |_________________________^
...
note: required by a bound in `futures::FutureExt::boxed`
   --> /Users/conrad.ludgate/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-util-0.3.31/src/future/future/mod.rs:516:23
    |
514 |     fn boxed<'a>(self) -> BoxFuture<'a, Self::Output>
    |        ----- required by a bound in this associated function
515 |     where
516 |         Self: Sized + Send + 'a,
    |                       ^^^^ required by this bound in `FutureExt::boxed`

I bisected this to the following commit f37aa99 (#147890).

I've been told that there is a post-mono trait solver pass that can be influenced by mir transforms, which would explain why I see this issue only with --release.

I was able to fix the issue with the following modifications

before:

pub async fn read_startup<S>(stream: &mut S) -> io::Result<FeStartupPacket>
where
    S: AsyncRead + Unpin,
{
    ...
}

after:

pub fn read_startup<S>(
    stream: &mut S,
) -> impl Future<Output = io::Result<FeStartupPacket>> + Send + '_
where
    S: AsyncRead + Unpin + Send,
{
    read_startup_inner(stream)
}

async fn read_startup_inner<S>(stream: &mut S) -> io::Result<FeStartupPacket>
where
    S: AsyncRead + Unpin + Send,
{
    ...
}

I know there's not a lot to go off of here, I apologise for this. As I say, I hope to have some time eventually to minimise this regression.

[eggyal]

@rustbot label +regression-from-stable-to-stable -regression-untriaged +E-needs-mcve

[conradludgate]

My colleague and I managed to minimise the repro into the following with no dependencies

fn main() {
    spawn(execution_loop(async || ()));

    spawn(task_main());
}

fn spawn<F: Send>(f: F) {
    drop(f);
}

impl<T: ?Sized> FutureExt for T where T: Future {}

trait FutureExt: Future {
    fn boxed<'a>(self) -> std::pin::Pin<Box<dyn Future<Output = Self::Output> + Send + 'a>>
    where
        Self: Sized + Send + 'a,
    {
        Box::pin(self)
    }
}

pub(crate) async fn execution_loop<F>(_f: F) {}

pub async fn task_main() {
    match_on_version().boxed().await;
}

#[derive(Clone, Copy, PartialEq)]
pub struct Version {
    major: u16,
}

impl Version {
    pub const fn new(major: u16) -> Self {
        Self { major }
    }
}

pub async fn match_on_version() -> bool {
    matches!(Version::new(18), COMPLEX_CONSTANT)
}

const COMPLEX_CONSTANT: Version = Version::new(1234);

Observe that cargo build succeeds, and cargo build --release produces the following error:

   Compiling rust-minimize-151748 v0.1.0 (/Users/conrad.ludgate/Documents/code/rust-minimize-151748)
error: cannot check whether the hidden type of opaque type satisfies auto traits
  --> src/main.rs:4:11
   |
 4 |     spawn(task_main());
   |     ----- ^^^^^^^^^^^
   |     |
   |     required by a bound introduced by this call
   |
   = note: fetching the hidden types of an opaque inside of the defining scope is not supported. You can try moving the opaque type and the item that actually registers a hidden type into a new submodule
note: opaque type is declared here
  --> src/main.rs:24:1
   |
24 | pub async fn task_main() {
   | ^^^^^^^^^^^^^^^^^^^^^^^^
note: required by a bound in `spawn`
  --> src/main.rs:7:13
   |
 7 | fn spawn<F: Send>(f: F) {
   |             ^^^^ required by this bound in `spawn`

error: could not compile `rust-minimize-151748` (bin "rust-minimize-151748") due to 1 previous error

[conradludgate]

Confirming that this also still fails to build on latest nightly