Why does using associated type cause 'a to be an invariant

[A4-Tacks]

trait Foo { type Ty; }

#[derive(Debug, Clone)]
//struct X<'a, T: Foo>(&'a T);
struct X<'a, T: Foo>(&'a T, T::Ty);
impl<T: Foo> Foo for X<'_, T> {
    type Ty = T::Ty;
}
impl Foo for () {
    type Ty = ();
}

fn f2<'a>(x: X<'a, X<'static, ()>>) -> X<'a, X<'a, ()>> {
    x
}

error: lifetime may not live long enough
  --> src/main.rs:14:5
   |
13 | fn f2<'a>(x: X<'a, X<'static, ()>>) -> X<'a, X<'a, ()>> {
   |       -- lifetime `'a` defined here
14 |     x
   |     ^ returning this value requires that `'a` must outlive `'static`
   |
   = note: requirement occurs because of the type `X<'_, X<'_, ()>>`, which makes the generic argument `X<'_, ()>` inv
ariant
   = note: the struct `X<'a, T>` is invariant over the parameter `T`
   = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance

error: could not compile `test_` (bin "test_") due to 1 previous error

rustc version:

rustc 1.80.0 (051478957 2024-07-21)
binary: rustc
commit-hash: 051478957371ee0084a7c0913941d2a8c4757bb9
commit-date: 2024-07-21
host: aarch64-unknown-linux-gnu
release: 1.80.0
LLVM version: 18.1.7

edition 2021

[fmease]

T::Ty forces X's T to be invariant because it may evaluate to (almost) arbitrary types which may reference T — and therefore one generally can't make assumptions about the 'concrete variance'. T::Ty may evaluate to e.g. T in which case it's covariant over T (assuming it's for X<'_, T>, T bare) or to e.g. fn(T) in which case it's contravariant over T (same assumption), etc. Hence invariance as a safe choice.

[fmease]

See also https://rust-lang.zulipchat.com/#narrow/stream/144729-t-types/topic/variance.20of.20GATs.20when.20the.20type.20is.20known