Async function leads to a "more general type" error

[stephaneyfx]

Rustc complains about a type being more general than the other when testing if the Future returned by an async function is Send. The same code without async sugar is accepted by the compiler.

This might be related to #60658.

I tried to minimize further, but removing .flatten(), the boxing with a trait object or even the mapping to an empty stream makes the code compile.

Playground

use futures::{
    future::ready,
    stream::{empty, iter},
    Stream, StreamExt,
};
use std::future::Future;
use std::pin::Pin;

fn is_send<T: Send>(_: T) {}

pub fn test() {
    let _ = is_send(make_future()); // Ok
    let _ = is_send(make_future_2());
}

fn make_future() -> impl Future<Output = ()> {
    iter(Some({
        let s = empty::<()>();
        Box::pin(s) as Pin<Box<dyn Stream<Item = ()> + Send + 'static>>
    }))
    .map(|_| empty::<()>())
    .flatten()
    .for_each(|_| ready(()))
}

// Same as make_future, just async
async fn make_future_2() {
    iter(Some({
        let s = empty::<()>();
        Box::pin(s) as Pin<Box<dyn Stream<Item = ()> + Send + 'static>>
    }))
    .map(|_| empty::<()>())
    .flatten()
    .for_each(|_| ready(()))
    .await
}

Expected result

It compiles successfully -- is_send(make_future()) and is_send(make_future_2()) are both accepted by the compiler.

Actual result

is_send(make_future_2()) is rejected with the following error:

error[E0308]: mismatched types
  --> src/lib.rs:13:13
   |
13 |     let _ = is_send(make_future_2());
   |             ^^^^^^^ one type is more general than the other
   |
   = note: expected type `std::ops::FnOnce<(std::pin::Pin<std::boxed::Box<dyn futures_core::stream::Stream<Item = ()> + std::marker::Send>>,)>`
              found type `std::ops::FnOnce<(std::pin::Pin<std::boxed::Box<dyn futures_core::stream::Stream<Item = ()> + std::marker::Send>>,)>`

[stephaneyfx]

Workaround: Moving the code creating the boxed stream to its own function also makes the code compile.
Playground

use futures::{
    future::ready,
    stream::{empty, iter},
    Stream, StreamExt,
};
use std::pin::Pin;

fn is_send<T: Send>(_: T) {}

pub fn test() {
    let _ = is_send(make_future_2());
}

async fn make_future_2() {
    iter(Some(make_stream()))
    .map(|_| empty::<()>())
    .flatten()
    .for_each(|_| ready(()))
    .await
}

fn make_stream() -> impl Stream<Item = ()> {
    let s = empty::<()>();
    Box::pin(s) as Pin<Box<dyn Stream<Item = ()> + Send + 'static>>
}

[Stargateur]

#71671 Because I like link

[nikomatsakis]

@rustbot claim

I will attempt to investigate.

[EliSnow]

I'm also encountering this in my project. I've spent the last two days trying all sorts of combinations to figure out what was going on to no avail. Then I found this issue. Thank you @stephaneyfx for the workaround. I guess I need to ditch async/await for this particular function.

Also note: having the function return impl Future<...> and wraping the async/await stuff in a block also repros the error https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=99744f965c62032dec5aac3e7b5795ca

[nikomatsakis]

Did a bit of digging around. I didn't quite figure out what's going on yet, but a few notes:

First, removing either of these calls makes the error go away

        .map(|_| empty::<()>())
        .flatten()

I'm feeling a bit confused about the types that I'm getting out right now. It looks like the error is somehow coming up around the "lifetime bound" that we get on the dyn Stream type.