Redundant trait bounds aren't ignored when checking if a trait object implements a trait

[sfackler]

This program doesn't compile:

trait Foo: Send + Sync {}

impl Foo for int {}

impl Foo for Box<Foo> {}

fn f<F: Foo>(_: F) {}

fn main() {
    let foo: Box<Foo+Send+Sync> = box 10i;
    f(foo)
}

test.rs:11:5: 11:6 error: the trait `Foo` is not implemented for the type `Box<Foo+Send+Sync>`
test.rs:11     f(foo)
               ^
test.rs:11:5: 11:6 note: the trait `Foo` must be implemented because it is required by `f`
test.rs:11     f(foo)
               ^
error: aborting due to previous error

I would expect that Box<Foo> would be the same type as Box<Foo+Send+Sync> because Foo requires Send+Sync.

[steveklabnik]

Triage: no change. Here's the updated code

#![feature(box_syntax)]
trait Foo: Send + Sync {}

impl Foo for i32 {}

impl Foo for Box<Foo> {}

fn f<F: Foo>(_: F) {}

fn main() {
    let foo: Box<Foo+Send+Sync> = box 10;
    f(foo)
}

[arielb1]

There is intentionally no subtyping relationship between Foo and Foo+Send+Sync - all subtyping in Rust is due to lifetimes (of course, the only reason for Box<Foo+Send+Sync> to implement Foo is because of an implicit impl).