error[E0401]: can't use generic parameters from outer function
  --> $DIR/type-arg-out-of-scope.rs:3:29
   |
LL | fn foo<T>(x: T) {
   |        - type parameter from outer function
LL |     fn bar(f: Box<dyn FnMut(T) -> T>) { }
   |        ---                  ^ use of generic parameter from outer function
   |        |
   |        help: try using a local generic parameter instead: `bar<T>`

error[E0401]: can't use generic parameters from outer function
  --> $DIR/type-arg-out-of-scope.rs:3:35
   |
LL | fn foo<T>(x: T) {
   |        - type parameter from outer function
LL |     fn bar(f: Box<dyn FnMut(T) -> T>) { }
   |        ---                        ^ use of generic parameter from outer function
   |        |
   |        help: try using a local generic parameter instead: `bar<T>`

error: aborting due to 2 previous errors

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