Provide way to refer to projected type

[Nemo157]

A couple of things I've wanted to do is to be able to destructure the projection to avoid using this. all the time in methods, and implement helper methods directly on the projection. As an example this currently works because of a lack of hygiene:

#[pin_project::pin_project]
struct Foo {
    #[pin]
    bar: &'static str,
}

impl __FooProjection<'_> {
    fn debug(&self) {
        println!("{:?}", self.bar);
    }
}

fn main() {
    let mut foo = Box::pin(Foo { bar: "baz" });
    foo.as_mut().project().debug();
    let __FooProjection { bar } = foo.as_mut().project();
    println!("{}", bar);
}

but it would be nice to have a way to do this that doesn't rely on the internal details of the macro.

[Nemo157]

I briefly experimented with a couple of ideas, the first was an inherent associated type:

impl Foo {
    type Projection = __FooProjection;
}

that's currently unsupported (rust-lang/rust#8995) and would presumably require GATs.

The other idea was to add a trait that had an associated type, which would need GATs as well.

My experiments with GAT workarounds seem to indicate that you can't use associated types as the base type in an impl block (impl Foo::Projection<'_> { ... }) or the constructor type in a destructuring statement (let Foo::Projection { bar } = ...;) anyway, so neither of those methods would work even if declaring the associated type worked.

[Nemo157]

Another horrible idea I had was

mod Foo {
    pub(super) type Projection<'a> = super::__FooProjection<'a>;
}

luckily modules and structs inhabit the same namespace so this is not possible.

[taiki-e]

I am thinking about two ways.
The first is to use an attribute too impl Foo and convert Foo to __FooProjection.

#[pin_project::project_impl]
impl Foo {
    fn debug(&self) {}
}

// convert to..
impl<'__pin> __FooProjection<'__pin> {
    fn debug(&self) {}
}

This way is almost the same as what the #[project] attribute currently does for let and match.

Another way is to allow naming the projected-type via the #[pin_project] attribute's argument.

#[pin_project::pin_project(projection = Bar)]
struct Foo {
    #[pin]
    bar: &'static str,
}

impl Bar<'_> {
    fn debug(&self) {}
}

We need to document that new lifetimes will be added, but this may be the best solution for this issue and rust-lang/pin-utils#21 at this time.

[Nemo157]

Oh yeah, I forgot about the #[project] attribute, I've been meaning to take a look at what it actually does. So that already covers the latter usecase, and it would make sense to do something similar for both.