Consider allowing naming the projected type

[taiki-e]

Currently, all ways for referring the projected type are provided by the #[project] attribute.

Ideally, I would like to write using inherent associated types (rust-lang/rust#8995) or generic associated types (rust-lang/rust#44265) as follows, but neither has been implemented yet:

impl Foo {
    type Projection<'pin> = __FooProjection<'pin>;
}

As implementing these features will take time (it seems that at least Chalk integration is necessary), we may allow naming as an alternative at this time.

I think there are two ways to provide these:

• Provide way to refer to projected type #43 (comment)

  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

• Add use statements support to #[project] attribute #85 (comment)
  

  pin-project/pin-project-internal/src/project.rs

  Line 240 in 4803d04

  // TODO: Consider allowing the projected type to be renamed by `#[project] use Foo as Bar`.

Related: #43

[taiki-e]

At this time I don't have a strong opinion about whether this should be added, but I am a bit concerned that this can complicate the API.

[taiki-e]

Given that #[project] isn't really available everywhere, I've come to feel that this makes sense.

Maybe something like this:

#[pin_project(project = FooProj, project_ref = FooProjRef)]
struct Foo<T> {
    #[pin]
    x T: ,
}

impl<T> Foo<'_, T> {}

(It should be mentioned in the documentation that a lifetime is added to the first position in generics.)

[taiki-e]

One of the cases that current #[project] cannot support is the following code.

#[pin_project::pin_project(Replace)]
enum E<T, U> {
    A(#[pin] T),
    B(U),
    C,
}

fn foo<T, U>(e: Pin<&mut E<T, Y>>) {
    if let E::A(_a) = e.project() { // needs #[project]
        // ..
    } else if E::B(_b) = e.project_replace(E::C) { // needs #[project_replace]
        //
    }
}

[taiki-e]

It should be mentioned in the documentation that a lifetime is added to the first position in generics.

Oh, it seems I forgot to do this in #202.