The bounds information of associated types is not propagated correctly when used with trait aliases.

[wdanilo]

Hi! The following code does not compile, while it should. The functions test1 and test2 do the same thing, while test1 compiles and test2 does not:

#![feature(trait_alias)]

use std::marker::PhantomData;

pub struct X{}

pub trait T2 = where PhantomData<Self>: Into<X>;

pub trait T {
    type Item: T2;
    
    fn test1() -> X {
        PhantomData::<Self::Item>.into()
    }
}

fn test2<S:T>(s:S) -> X {
    PhantomData::<S::Item>.into()
}

Error:

error[E0277]: the trait bound `X: std::convert::From<std::marker::PhantomData<<S as T>::Item>>` is not satisfied
  --> src/lib.rs:18:28
   |
18 |     PhantomData::<S::Item>.into()
   |                            ^^^^ the trait `std::convert::From<std::marker::PhantomData<<S as T>::Item>>` is not implemented for `X`
   |
   = note: required because of the requirements on the impl of `std::convert::Into<X>` for `std::marker::PhantomData<<S as T>::Item>`

[jonas-schievink]

...is pub trait T2 = where PhantomData<Self>: Into<X>; supposed to be allowed? That looks like really weird syntax.

[wdanilo]

@jonas-schievink, as I've written in my original message, if you comment out test2, everything compiles fine. This syntax is weird, like many other syntax parts in Rust :P Anyway, this just means that we create a trait alias that does not apply constraints to Self but apply constraints to more complex types.

The close / reopen below was accidental - sorry for that.

[jonas-schievink]

Ah, the RFC does specify that as valid syntax

[Aaron1011]

Are we 100% sure that this is supposed to be allowed? The RFC does contain examples of using Self in the where clause, without any other bounds outside the where clause. However, there's no discussion of using Self as a parameter, and of bounding other types.

If so, do we want to allow things like trait Foo = where u32: Copy, which (effectively) don't actually constrain anything?

Getting even crazier, what about something like trait Foo = where String: Copy with #![feature(trivial_bounds)]?

[Aaron1011]

Having though about this more, I think that this should probably be allowed (though I still think that the the where-clause-only case is kind of weird). Something like this should definitely compiler:

trait Foo = Bar where Something<Self>: OtherTrait

Since this is something that you could reasonably write inline (without a trait alias). I think it's better to have only one notion of where clauses in the language, rather than having "fully capable" where clauses and "limited" (in trait aliases) where clauses.