Implementation of GATs outlives lint

[jackh726]

See #87479 for background. Closes #87479

The basic premise of this lint/error is to require the user to write where clauses on a GAT when those bounds can be implied or proven from any function on the trait returning that GAT.

Intuitive Explanation (Attempt)

Let's take this trait definition as an example:

trait Iterable {
    type Item<'x>;
    fn iter<'a>(&'a self) -> Self::Item<'a>;
}

Let's focus on the iter function. The first thing to realize is that we know that Self: 'a because of &'a self. If an impl wants Self::Item to contain any data with references, then those references must be derived from &'a self. Thus, they must live only as long as 'a. Furthermore, because of the Self: 'a implied bound, they must live only as long as Self. Since it's 'a is used in place of 'x, it is reasonable to assume that any value of Self::Item<'x>, and thus 'x, will only be able to live as long as Self. Therefore, we require this bound on Item in the trait.

As another example:

trait Deserializer<T> {
    type Out<'x>;
    fn deserialize<'a>(&self, input: &'a T) -> Self::Out<'a>;
}

The intuition is similar here, except rather than a Self: 'a implied bound, we have a T: 'a implied bound. Thus, the data on Self::Out<'a> is derived from &'a T, and thus it is reasonable to expect that the lifetime 'x will always be less than T.

Implementation Algorithm

• Given a GAT <P0 as Trait<P1..Pi>>::G<Pi...Pn> declared as trait T<A1..Ai> for A0 { type G<Ai...An>; } used in return type of one associated function F
• Given env E (including implied bounds) for F
• For each lifetime parameter 'a in P0...Pn:
  • For each other type parameter Pi != 'a in P0...Pn: // FIXME: this include of lifetime parameters too
    • If E => (P: 'a):
      • Require where clause Ai: 'a

Follow-up questions

• What should we do when we don't pass params exactly?
  For this example:

trait Des {
    type Out<'x, D>;
    fn des<'z, T>(&self, data: &'z Wrap<T>) -> Self::Out<'z, Wrap<T>>;
}

Should we be requiring a D: 'x clause? We pass Wrap<T> as D and 'z as 'x, and should be able to prove that Wrap<T>: 'z.

r? @nikomatsakis

[nikomatsakis]

Hi @jackh726 -- left a bunch of comments, mostly nits. The most significant one is the question of what to do in the case of multiple functions.

[nikomatsakis]

nit: lowercase letter

[nikomatsakis]

I think we can do more to give an intuitive understanding here. I'd like the message to be something like this...

error: associated type `TRef` must declare that it may borrow from `Self`
  --> $DIR/issue-86787.rs:11:5
   |
LL |     type TRef<'a>;
   |     ^^^^^^^^^^^^^-
   |                  |
   |                  help: add the required where clauses: `where Self: 'a`
LL |     fn ref_children<'a>(&'a self) -> Vec<Self::TRef<'a>>;
   |        ^^^^^^^^^^^^
   |        |
   |        in this function, `TRef` could return content from the type `Self`, borrowed for `'a`
    note: This where clause is required because we expect to add it as a default in the future. If adding this where clause causes your use case not to work, please visit https://rust-lang.github.io/generic-associated-types-initiative/ to give feedback (and to see the workaround).

[nikomatsakis]

Obviously these spans are not as precise as they could be, and the wording can probably be improved. I was trying to give what seemed like a realistic message based on the content we currently have available

[nikomatsakis]

Had a thought as I was writing the explainer:

We might need to extend these errors. Consider this case:

trait Iterable {
    type Item<'a>;

    type Iterator<'a>: Iterator<Item = Self::Item<'a>>;

    fn iter<'a>(&'a self) -> Self::Iterator<'a>;
}

Here, the method implies that Iterator needs where Self: 'a, but Item does too. I think we can see that from the fact that references to Item<'a> appear in the bounds of Iterator, and we inferred that 'a represents the "lifetime of a borrow from Self" when using Iterator, so it probably does for Item too.

[jackh726]

This isn't right

[jackh726]

Nor this.

[jackh726]

@nikomatsakis I've addressed the nits here. But have not yet reworked the diagnostic. I also added checking for region outlives region. I have not started working out the Iterable case and there tests where we have a lifetime on the trait, not the method could be cleaned up a bit (currently require Self: 'a and Self: 'b, when really we probably should pick one...maybe the trait parameter name)

[nikomatsakis]

OK, this is looking pretty clean right now. r=me with the various comments addressed (or with FIXMEs created). I know it's not in the complete end state we want, but I'd also be ok to land it and iterate in tree.

[nikomatsakis]

Suggested change

	/// Require that the user writes as where clauses on GATs the implicit
	/// outlives bounds involving trait parameters in trait functions and
	/// Require that the user writes where clauses on GATs for the implicit
	/// outlives bounds involving trait parameters in trait functions and

[jackh726]

@bors r=nikomatsakis

[bors]

📌 Commit b6edcbd has been approved by nikomatsakis

[bors]

⌛ Testing commit b6edcbd with merge 9d39f6a...

[bors]

☀️ Test successful - checks-actions
Approved by: nikomatsakis
Pushing 9d39f6a to master...

[rust-timer]

Finished benchmarking commit (9d39f6a): comparison url.

Summary: This benchmark run did not return any relevant changes.

If you disagree with this performance assessment, please file an issue in rust-lang/rustc-perf.

@rustbot label: -perf-regression

[jackh726]

@MingweiSamuel this is weird...maybe try to cargo clean and rebuild?