Use auto_impl to delegate Box implementation

[ebkalderon]

Changed

• Use auto_impl to delegate implementation of Box<S> where S: LanguageServer + ?Sized.

It turns out that auto_impl can work with async-trait as long as the auto_impl invocation occurs first, such that the #[auto_impl] macro receives the desugared output of #[async_trait].

Original suggestion from #107 (comment).

CC @icsaszar

[ebkalderon]

Hmm, seems like merging this would be a breaking API change and a loss of functionality, since auto_impl is refusing to add the ?Sized bound to the generated impl.

fn assert_impl<T: LanguageServer>() {}

fn foo() {
    assert_impl::<Box<dyn LanguageServer>>(); // ERROR: Not object safe with `auto_impl`
}

According to auto-impl-rs/auto_impl#54, adding ?Sized should be supported by the macro, and the async-trait README confirms that traits can be made object safe and unsized if the Sync bound is added, which it is. Not sure why it's not doing it, though. I'll look into this further when I have time.

[ebkalderon]

I had something of a realization that this may be impossible to get to work because the codegen for auto_impl doesn't know to wrap the method bodies in a Box::pin(async move { ... }) like async-trait does. I think I'll just close this pull request for now and stick with a manual Box implementation for this trait unless auto-impl-rs/auto_impl#65 can be resolved. If it is achievable, we can always reopen this PR.

[dtolnay]

I don't know why wrapping the method body in Box::pin(async move { ... }) would be necessary. Returning the same pinned future constructed by the trait object should be fine like all other traits.

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

struct Error;

trait Foo: Sync {
    fn bar<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<u32, Error>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
}

impl<T: Foo + ?Sized> Foo for Box<T>
where
    Box<T>: Sync,
{
    fn bar<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<u32, Error>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait,
    {
        Foo::bar(&**self)
    }
}

fn main() {
    fn assert_impl<T: Foo>() {}
    assert_impl::<Box<dyn Foo>>();
}

[ebkalderon]

Good point, @dtolnay . I didn't think of that! I had imagined an async fn body with an .await in my head when picturing the async-trait codegen, and I didn't consider returning the Foo::bar() future itself without bothering to .await it inside of a Box::pin(async {}).