error[E0277]: the trait bound `u32: Trait` is not satisfied
  --> $DIR/on-structs-and-enums-in-fns.rs:13:15
   |
LL | fn explode(x: Foo<u32>) {}
   |               ^^^^^^^^ the trait `Trait` is not implemented for `u32`
   |
help: this trait has no implementations, consider adding one
  --> $DIR/on-structs-and-enums-in-fns.rs:1:1
   |
LL | trait Trait {}
   | ^^^^^^^^^^^
note: required by a bound in `Foo`
  --> $DIR/on-structs-and-enums-in-fns.rs:3:14
   |
LL | struct Foo<T:Trait> {
   |              ^^^^^ required by this bound in `Foo`

error[E0277]: the trait bound `f32: Trait` is not satisfied
  --> $DIR/on-structs-and-enums-in-fns.rs:16:14
   |
LL | fn kaboom(y: Bar<f32>) {}
   |              ^^^^^^^^ the trait `Trait` is not implemented for `f32`
   |
help: this trait has no implementations, consider adding one
  --> $DIR/on-structs-and-enums-in-fns.rs:1:1
   |
LL | trait Trait {}
   | ^^^^^^^^^^^
note: required by a bound in `Bar`
  --> $DIR/on-structs-and-enums-in-fns.rs:7:12
   |
LL | enum Bar<T:Trait> {
   |            ^^^^^ required by this bound in `Bar`

error: aborting due to 2 previous errors

For more information about this error, try `rustc --explain E0277`.
