GAT: Fails to compile with additional bounds

[Ddystopia]

I tried this code:

trait Gat {
    type Assoc<'a>;
}

struct Foo<S>(S);

impl<S> Foo<S> {
    fn bar<'a, C, T>(&self)
    where
        C: Gat<Assoc<'a> = T>,
        C: Gat<Assoc<'static> = S>, // By commenting out this bound code will compile
    {
        self.foo::<C, T>(); // or comment out this line, it will compile too
    }

    fn foo<'a, C, T>(&self)
    where
        C: Gat<Assoc<'a> = T>,
        // To be closer to original code `C: Gat<Assoc<'static> = S>` may be included, but error is the same anyway
    {
    }
}

I expected to see this happen: Code should compile

Instead, this happened: Code did not compile. Probably because 'a is different in both cases, I but cannot specify lifetime arguments explicitly if late bound lifetime parameters are present #42868 .

 1  error[E0284]: type annotations needed: cannot satisfy `<C as Gat>::Assoc<'_> == T`
   --> src/main.rs:13:14
    |
 13 |         self.foo::<C, T>();
    |              ^^^ cannot satisfy `<C as Gat>::Assoc<'_> == T`
    |
 note: required by a bound in `Foo::<S>::foo`
   --> src/main.rs:18:16
    |
 16 |     fn foo<'a, C, T>(&self)
    |        --- required by a bound in this associated function
 17 |     where
 18 |         C: Gat<Assoc<'a> = T>,
    |                ^^^^^^^^^^^^^ required by this bound in `Foo::<S>::foo`

Meta

rustc --version --verbose:

rustc 1.87.0-nightly (b48576b4d 2025-03-22)
binary: rustc
commit-hash: b48576b4db5a595f453891f0b7243ef75d8c0afa
commit-date: 2025-03-22
host: x86_64-unknown-linux-gnu
release: 1.87.0-nightly
LLVM version: 20.1.1

[fmease]

This works as intended. You generally cannot define/have impls that only differ by (same-rank) lifetimes since lifetimes are erased for codegen, so it wouldn't be able to differentiate them.

Such impls (e.g., impl<'a> Trait for &'a () {} and impl Trait for &'static () {} are considered conflicting since they only differ by (same-rank) lifetime ('a vs. 'static)).

As a consequence, bounds containing equality constraints that match on (same-rank) lifetimes are considered ambiguous like in

fn f<'a, T/*: 'static*/>()
where
    &'a T: Trait0<Type = i32>, //~ ERROR type annotations needed: cannot satisfy
    &'static T: Trait0<Type = ()> {}

or in

fn f<'a, T>()
where
    T: Trait1<'a, Type = i32>, //~ ERROR type annotations needed: cannot satisfy
    T: Trait1<'static, Type = ()> {}

or as seen in your GAT example.

[fmease]

The error message could be better tho.

[Ddystopia]

Are you sure? If remove the call to foo, code compiles too. It is already usable and works. The only limitation is that I cannot call those functions inside other functions like that, forcing me to have code duplication or unsafe common function without type system's protection.

[fmease]

Oof, I should've looked more closely, my bad. Right, it's not impossible to call Foo::bar.

[fmease]

I mean I guess what I wrote previously about lifetimes is still the root cause ultimately.

Given only C: Gat<Assoc<'a> = T> in bar's environment, you can trivially prove C: Gat<Assoc<'a> = T> as required by foo.

However, once you have given C: Gat<Assoc<'a> = T> and C: Gat<Assoc<'static> = S> and want to prove C: Gat<Assoc<'a> = T> or more precisely <C as Gat>::Assoc<'a> == T you fail because <C as Gat>::Assoc<'a> no longer normalizes to T via the environment (since it could also normalize to S since we're still dealing modulo (same-rank) lifetimes). It's considered ambiguous (T and S are rigid here and thus not equal).

[fmease]

I might be mistaken I don't think this is fixable in Rust's current type system.

Edit: But let's see what others have to say. I remember there already being ago-old GH issues about this.

[fmease]

#21974 comes to mind