dyn Trait + Send+ Send should equal dyn Trait + Send

[Havvy]

For some trait, Trait, the following is a legal type: type Send2 = Trait + Send + Send.

Not only that, but the type is actually distinct from type Send1 = Trait + Send. E.g., you can put inherent methods on both, and call them distinctly. I've a full example of this here.

Unfortunately, this is already in stable Rust, but at the same time, I don't think anybody is actually relying on this corner of the language. It should be an error to have the same trait twice in a trait object (except perhaps via generics), or at least make cases like Send1 and Send2 be equivalent.

[kennytm]

except perhaps via generics

You can't write type WithSend<T: ?Sized> = T + Send (causes E0404 "not a trait"), so denying it should be safe.

However I'm not sure if these should be considered equivalent, or different, or rejected.

trait X: Send {}

type A = X;
type B = X + Send;

// A == B ?

[petrochenkov]

fn f<T: Write + Send + Send>() {}

is legal, so dyn Write + Send + Send should be legal as well, stating a predicate twice is redundancy, but not an error.

This can also be useful with trait aliases - dyn TraitAlias + Send, where TraitAlias may include Send as well.

Looks like the bounds just need to be "normalized" somehow (e.g. sorted and deduplicated) when lowering from syntactic to semantic form.
This is somewhat similar to #33140.