for<'a> Send is distinct from Send?

[sfackler]

This code fails to compile with a pretty strange error:

use std::future::Future;
use std::pin::Pin;
use std::io::Read;

trait Service<R> {
    type Response;
    type Error;
    type Future: Future<Output = Result<Self::Response, Self::Error>>;
    
    fn call(&mut self, req: R) -> Self::Future;
}

struct BorrowerService<S> {
    service: Option<S>,
}

impl<S> Service<Box<dyn Read + Sync + Send>> for BorrowerService<S>
where
    for<'b> S: Service<&'b (dyn Read + 'static + Sync + Send), Response = i32, Error = ()> + 'static + Send,
    for<'b> <S as Service<&'b (dyn Read + 'static + Sync + Send)>>::Future: Send,
{
    type Response = i32;
    type Error = ();
    type Future = Pin<Box<dyn Future<Output = Result<i32, ()>> + Send>>;
    
    fn call(&mut self, req: Box<dyn Read + Sync + Send>) -> Self::Future {
        let mut service = self.service.take().unwrap();
        Box::pin(async move {
            service.call(&req).await
        })
    }
}

error[E0308]: mismatched types
  --> src/lib.rs:28:9
   |
28 | /         Box::pin(async move {
29 | |             service.call(&req).await
30 | |         })
   | |__________^ one type is more general than the other
   |
   = note: expected type `std::marker::Send`
              found type `for<'b> std::marker::Send`

The use of the trait object appears to be important - if I replace that with e.g. String, it compiles just fine:

use std::future::Future;
use std::pin::Pin;

trait Service<R> {
    type Response;
    type Error;
    type Future: Future<Output = Result<Self::Response, Self::Error>>;
    
    fn call(&mut self, req: R) -> Self::Future;
}

struct BorrowerService<S> {
    service: Option<S>,
}

impl<S> Service<Box<String>> for BorrowerService<S>
where
    for<'b> S: Service<&'b String, Response = i32, Error = ()> + 'static + Send,
    for<'b> <S as Service<&'b String>>::Future: Send,
{
    type Response = i32;
    type Error = ();
    type Future = Pin<Box<dyn Future<Output = Result<i32, ()>> + Send>>;
    
    fn call(&mut self, req: Box<String>) -> Self::Future {
        let mut service = self.service.take().unwrap();
        Box::pin(async move {
            service.call(&req).await
        })
    }
}

[lcnr]

somewhat minimized

use std::future::Future;

trait Service<R> {
    type Future: Future<Output = i32>;
    
    fn call(&mut self, req: R) -> Self::Future;
}

struct BorrowerService<S> {
    service: Option<S>,
}

impl<S> Service<Box<dyn Sync + Send>> for BorrowerService<S>
where
    for<'b> S: Service<&'b (dyn 'static + Sync + Send)> + 'static + Send,
    for<'b> <S as Service<&'b (dyn 'static + Sync + Send)>>::Future: Send,
{
    type Future = Box<dyn Future<Output = i32> + Send>;
    
    fn call(&mut self, req: Box<dyn Sync + Send>) -> Self::Future {
        let mut service = self.service.take().unwrap();
        Box::new(async move {
            service.call(&req).await
        })
    }
}

[eddyb]

cc @rust-lang/wg-traits

[sfackler]

Here's a variant that doesn't involve trait objects at all:

trait Service<R> {
    type Future;
}

struct Inner;

impl<R> Service<R> for Inner {
    type Future = ();
}

struct Outer<S> {
    inner: S,
}

impl<S> Service<()> for Outer<S>
where
    for<'a> S: Service<&'a ()>,
    for<'a> <S as Service<&'a ()>>::Future: Send,
{
    type Future = ();
}

fn is_service<S>(_: S)
where
    S: Service<()>
{}

fn main() {
    is_service(Outer { inner: Inner })
}

error[E0277]: `<Inner as Service<&'a ()>>::Future` cannot be sent between threads safely
  --> src/main.rs:29:5
   |
23 | fn is_service<S>(_: S)
   |    ---------- required by a bound in this
24 | where
25 |     S: Service<()>
   |        ----------- required by this bound in `is_service`
...
29 |     is_service(Outer { inner: Inner })
   |     ^^^^^^^^^^ `<Inner as Service<&'a ()>>::Future` cannot be sent between threads safely
   |
   = help: the trait `for<'a> std::marker::Send` is not implemented for `<Inner as Service<&'a ()>>::Future`
   = note: required because of the requirements on the impl of `Service<()>` for `Outer<Inner>`

error: aborting due to previous error

For more information about this error, try `rustc --explain E0277`.

The error seems bogus, since Inner's future type is (), which is definitely Send, but for<'a> Send is apparently not the same thing!

[lcnr]

It looks to me like the issue is that we do not normalize projections which are inside of binders, so we are currently unable to normalize for<'a> <ConcreteTy as Trait<'a>>::Assoc until 'a is replaced with a concrete lifetime.

While I would be interested in implementing normalization inside of binders, I do not think that we currently have the capacity to do so.

[sfackler]

It looks like this has been at least partially fixed. The reproducer without trait objects compiles successfully today, while the original example fails with a different error that sounds a bit like #102211

error: higher-ranked lifetime error
  --> src/lib.rs:28:9
   |
28 | /         Box::pin(async move {
29 | |             service.call(&req).await
30 | |         })
   | |__________^
   |
   = note: could not prove `Pin<Box<[async block@src/lib.rs:28:18: 30:10]>>: CoerceUnsized<Pin<Box<(dyn Future<Output = Result<i32, ()>> + Send + 'b)>>>`

error: could not compile `playground` (lib) due to previous error