error[E0261]: use of undeclared lifetime name `'a`
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:11:22
   |
LL |     fn bar(self, _: &'a Trait) {}
   |                      ^^ undeclared lifetime
   |
help: consider introducing lifetime `'a` here
   |
LL |     fn bar<'a>(self, _: &'a Trait) {}
   |           ++++
help: consider introducing lifetime `'a` here
   |
LL | impl<'a> IceCream {
   |     ++++

error[E0106]: missing lifetime specifier
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:21:17
   |
LL |     fn cat() -> &Trait {
   |                 ^ expected named lifetime parameter
   |
   = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`
   |
LL |     fn cat() -> &'static Trait {
   |                  +++++++

error[E0106]: missing lifetime specifier
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:27:21
   |
LL |     fn dog<'a>() -> &Trait {
   |                     ^ expected named lifetime parameter
   |
   = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'a` lifetime
   |
LL |     fn dog<'a>() -> &'a Trait {
   |                      ++

error[E0261]: use of undeclared lifetime name `'a`
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:33:21
   |
LL |     fn kitten() -> &'a Trait {
   |                     ^^ undeclared lifetime
   |
help: consider introducing lifetime `'a` here
   |
LL |     fn kitten<'a>() -> &'a Trait {
   |              ++++
help: consider introducing lifetime `'a` here
   |
LL | impl<'a> IceCream {
   |     ++++

error[E0106]: missing lifetime specifier
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:44:20
   |
LL |     fn parrot() -> &mut Trait {
   |                    ^ expected named lifetime parameter
   |
   = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`
   |
LL |     fn parrot() -> &'static mut Trait {
   |                     +++++++

error[E0261]: use of undeclared lifetime name `'a`
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:55:16
   |
LL |     fn bar(_: &'a Trait);
   |                ^^ undeclared lifetime
   |
help: consider introducing lifetime `'a` here
   |
LL |     fn bar<'a>(_: &'a Trait);
   |           ++++
help: consider introducing lifetime `'a` here
   |
LL | trait Sing<'a> {
   |           ++++

error[E0106]: missing lifetime specifier
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:65:17
   |
LL |     fn cat() -> &Trait;
   |                 ^ expected named lifetime parameter
   |
   = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`
   |
LL |     fn cat() -> &'static Trait;
   |                  +++++++
help: instead, you are more likely to want to return an owned value
   |
LL -     fn cat() -> &Trait;
LL +     fn cat() -> Trait;
   |

error[E0106]: missing lifetime specifier
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:69:21
   |
LL |     fn dog<'a>() -> &Trait {
   |                     ^ expected named lifetime parameter
   |
   = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'a` lifetime
   |
LL |     fn dog<'a>() -> &'a Trait {
   |                      ++

error[E0261]: use of undeclared lifetime name `'a`
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:75:21
   |
LL |     fn kitten() -> &'a Trait {
   |                     ^^ undeclared lifetime
   |
help: consider introducing lifetime `'a` here
   |
LL |     fn kitten<'a>() -> &'a Trait {
   |              ++++
help: consider introducing lifetime `'a` here
   |
LL | trait Sing<'a> {
   |           ++++

error[E0106]: missing lifetime specifier
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:86:20
   |
LL |     fn parrot() -> &mut Trait {
   |                    ^ expected named lifetime parameter
   |
   = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`
   |
LL |     fn parrot() -> &'static mut Trait {
   |                     +++++++

error[E0261]: use of undeclared lifetime name `'a`
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:96:12
   |
LL | fn bar(_: &'a Trait) {}
   |       -    ^^ undeclared lifetime
   |       |
   |       help: consider introducing lifetime `'a` here: `<'a>`

error[E0106]: missing lifetime specifier
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:110:13
   |
LL | fn cat() -> &Trait {
   |             ^ expected named lifetime parameter
   |
   = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`
   |
LL | fn cat() -> &'static Trait {
   |              +++++++

error[E0106]: missing lifetime specifier
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:116:17
   |
LL | fn dog<'a>() -> &Trait {
   |                 ^ expected named lifetime parameter
   |
   = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'a` lifetime
   |
LL | fn dog<'a>() -> &'a Trait {
   |                  ++

error[E0261]: use of undeclared lifetime name `'a`
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:122:17
   |
LL | fn kitten() -> &'a Trait {
   |          -      ^^ undeclared lifetime
   |          |
   |          help: consider introducing lifetime `'a` here: `<'a>`

error[E0106]: missing lifetime specifier
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:133:16
   |
LL | fn parrot() -> &mut Trait {
   |                ^ expected named lifetime parameter
   |
   = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`
   |
LL | fn parrot() -> &'static mut Trait {
   |                 +++++++

error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:52:16
   |
LL |     fn foo(_: &Trait);
   |                ^^^^^
   |
help: use a new generic type parameter, constrained by `Trait`
   |
LL |     fn foo<T: Trait>(_: &T);
   |           ++++++++++     ~
help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
   |
LL |     fn foo(_: &impl Trait);
   |                ++++
help: alternatively, use a trait object to accept any type that implements `Trait`, accessing its methods at runtime using dynamic dispatch
   |
LL |     fn foo(_: &dyn Trait);
   |                +++

error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:55:19
   |
LL |     fn bar(_: &'a Trait);
   |                   ^^^^^
   |
help: use a new generic type parameter, constrained by `Trait`
   |
LL |     fn bar<T: Trait>(_: &'a T);
   |           ++++++++++        ~
help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
   |
LL |     fn bar(_: &'a impl Trait);
   |                   ++++
help: alternatively, use a trait object to accept any type that implements `Trait`, accessing its methods at runtime using dynamic dispatch
   |
LL |     fn bar(_: &'a dyn Trait);
   |                   +++

error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:59:22
   |
LL |     fn alice<'a>(_: &Trait);
   |                      ^^^^^
   |
help: use a new generic type parameter, constrained by `Trait`
   |
LL |     fn alice<'a, T: Trait>(_: &T);
   |                ++++++++++      ~
help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
   |
LL |     fn alice<'a>(_: &impl Trait);
   |                      ++++
help: alternatively, use a trait object to accept any type that implements `Trait`, accessing its methods at runtime using dynamic dispatch
   |
LL |     fn alice<'a>(_: &dyn Trait);
   |                      +++

error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:62:23
   |
LL |     fn bob<'a>(_: &'a Trait);
   |                       ^^^^^
   |
help: use a new generic type parameter, constrained by `Trait`
   |
LL |     fn bob<'a, T: Trait>(_: &'a T);
   |              ++++++++++         ~
help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
   |
LL |     fn bob<'a>(_: &'a impl Trait);
   |                       ++++
help: alternatively, use a trait object to accept any type that implements `Trait`, accessing its methods at runtime using dynamic dispatch
   |
LL |     fn bob<'a>(_: &'a dyn Trait);
   |                       +++

error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:65:18
   |
LL |     fn cat() -> &Trait;
   |                  ^^^^^
   |
help: use `impl Trait` to return an opaque type, as long as you return a single underlying type
   |
LL |     fn cat() -> &impl Trait;
   |                  ++++
help: alternatively, you can return an owned trait object
   |
LL |     fn cat() -> Box<dyn Trait>;
   |                 ~~~~~~~~~~~~~~

error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:69:22
   |
LL |     fn dog<'a>() -> &Trait {
   |                      ^^^^^
   |
help: use `impl Trait` to return an opaque type, as long as you return a single underlying type
   |
LL |     fn dog<'a>() -> &impl Trait {
   |                      ++++
help: alternatively, you can return an owned trait object
   |
LL |     fn dog<'a>() -> Box<dyn Trait> {
   |                     ~~~~~~~~~~~~~~

error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:75:24
   |
LL |     fn kitten() -> &'a Trait {
   |                        ^^^^^
   |
help: use `impl Trait` to return an opaque type, as long as you return a single underlying type
   |
LL |     fn kitten() -> &'a impl Trait {
   |                        ++++
help: alternatively, you can return an owned trait object
   |
LL |     fn kitten() -> Box<dyn Trait> {
   |                    ~~~~~~~~~~~~~~

error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:81:27
   |
LL |     fn puppy<'a>() -> &'a Trait {
   |                           ^^^^^
   |
help: use `impl Trait` to return an opaque type, as long as you return a single underlying type
   |
LL |     fn puppy<'a>() -> &'a impl Trait {
   |                           ++++
help: alternatively, you can return an owned trait object
   |
LL |     fn puppy<'a>() -> Box<dyn Trait> {
   |                       ~~~~~~~~~~~~~~

error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:86:25
   |
LL |     fn parrot() -> &mut Trait {
   |                         ^^^^^
   |
help: use `impl Trait` to return an opaque type, as long as you return a single underlying type
   |
LL |     fn parrot() -> &mut impl Trait {
   |                         ++++
help: alternatively, you can return an owned trait object
   |
LL |     fn parrot() -> Box<dyn Trait> {
   |                    ~~~~~~~~~~~~~~

error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:93:12
   |
LL | fn foo(_: &Trait) {}
   |            ^^^^^
   |
help: use a new generic type parameter, constrained by `Trait`
   |
LL | fn foo<T: Trait>(_: &T) {}
   |       ++++++++++     ~
help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
   |
LL | fn foo(_: &impl Trait) {}
   |            ++++
help: alternatively, use a trait object to accept any type that implements `Trait`, accessing its methods at runtime using dynamic dispatch
   |
LL | fn foo(_: &dyn Trait) {}
   |            +++

error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:96:15
   |
LL | fn bar(_: &'a Trait) {}
   |               ^^^^^
   |
help: use a new generic type parameter, constrained by `Trait`
   |
LL | fn bar<T: Trait>(_: &'a T) {}
   |       ++++++++++        ~
help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
   |
LL | fn bar(_: &'a impl Trait) {}
   |               ++++
help: alternatively, use a trait object to accept any type that implements `Trait`, accessing its methods at runtime using dynamic dispatch
   |
LL | fn bar(_: &'a dyn Trait) {}
   |               +++

error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:100:18
   |
LL | fn alice<'a>(_: &Trait) {}
   |                  ^^^^^
   |
help: use a new generic type parameter, constrained by `Trait`
   |
LL | fn alice<'a, T: Trait>(_: &T) {}
   |            ++++++++++      ~
help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
   |
LL | fn alice<'a>(_: &impl Trait) {}
   |                  ++++
help: alternatively, use a trait object to accept any type that implements `Trait`, accessing its methods at runtime using dynamic dispatch
   |
LL | fn alice<'a>(_: &dyn Trait) {}
   |                  +++

error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:103:19
   |
LL | fn bob<'a>(_: &'a Trait) {}
   |                   ^^^^^
   |
help: use a new generic type parameter, constrained by `Trait`
   |
LL | fn bob<'a, T: Trait>(_: &'a T) {}
   |          ++++++++++         ~
help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
   |
LL | fn bob<'a>(_: &'a impl Trait) {}
   |                   ++++
help: alternatively, use a trait object to accept any type that implements `Trait`, accessing its methods at runtime using dynamic dispatch
   |
LL | fn bob<'a>(_: &'a dyn Trait) {}
   |                   +++

error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:110:14
   |
LL | fn cat() -> &Trait {
   |              ^^^^^
   |
help: use `impl Trait` to return an opaque type, as long as you return a single underlying type
   |
LL | fn cat() -> &impl Trait {
   |              ++++
help: alternatively, you can return an owned trait object
   |
LL | fn cat() -> Box<dyn Trait> {
   |             ~~~~~~~~~~~~~~

error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:116:18
   |
LL | fn dog<'a>() -> &Trait {
   |                  ^^^^^
   |
help: use `impl Trait` to return an opaque type, as long as you return a single underlying type
   |
LL | fn dog<'a>() -> &impl Trait {
   |                  ++++
help: alternatively, you can return an owned trait object
   |
LL | fn dog<'a>() -> Box<dyn Trait> {
   |                 ~~~~~~~~~~~~~~

error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:122:20
   |
LL | fn kitten() -> &'a Trait {
   |                    ^^^^^
   |
help: use `impl Trait` to return an opaque type, as long as you return a single underlying type
   |
LL | fn kitten() -> &'a impl Trait {
   |                    ++++
help: alternatively, you can return an owned trait object
   |
LL | fn kitten() -> Box<dyn Trait> {
   |                ~~~~~~~~~~~~~~

error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:128:23
   |
LL | fn puppy<'a>() -> &'a Trait {
   |                       ^^^^^
   |
help: use `impl Trait` to return an opaque type, as long as you return a single underlying type
   |
LL | fn puppy<'a>() -> &'a impl Trait {
   |                       ++++
help: alternatively, you can return an owned trait object
   |
LL | fn puppy<'a>() -> Box<dyn Trait> {
   |                   ~~~~~~~~~~~~~~

error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:133:21
   |
LL | fn parrot() -> &mut Trait {
   |                     ^^^^^
   |
help: use `impl Trait` to return an opaque type, as long as you return a single underlying type
   |
LL | fn parrot() -> &mut impl Trait {
   |                     ++++
help: alternatively, you can return an owned trait object
   |
LL | fn parrot() -> Box<dyn Trait> {
   |                ~~~~~~~~~~~~~~

error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:8:16
   |
LL |     fn foo(_: &Trait) {}
   |                ^^^^^
   |
help: use a new generic type parameter, constrained by `Trait`
   |
LL |     fn foo<T: Trait>(_: &T) {}
   |           ++++++++++     ~
help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
   |
LL |     fn foo(_: &impl Trait) {}
   |                ++++
help: alternatively, use a trait object to accept any type that implements `Trait`, accessing its methods at runtime using dynamic dispatch
   |
LL |     fn foo(_: &dyn Trait) {}
   |                +++

error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:11:25
   |
LL |     fn bar(self, _: &'a Trait) {}
   |                         ^^^^^
   |
help: use a new generic type parameter, constrained by `Trait`
   |
LL |     fn bar<T: Trait>(self, _: &'a T) {}
   |           ++++++++++              ~
help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
   |
LL |     fn bar(self, _: &'a impl Trait) {}
   |                         ++++
help: alternatively, use a trait object to accept any type that implements `Trait`, accessing its methods at runtime using dynamic dispatch
   |
LL |     fn bar(self, _: &'a dyn Trait) {}
   |                         +++

error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:15:29
   |
LL |     fn alice<'a>(&self, _: &Trait) {}
   |                             ^^^^^
   |
help: use a new generic type parameter, constrained by `Trait`
   |
LL |     fn alice<'a, T: Trait>(&self, _: &T) {}
   |                ++++++++++             ~
help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
   |
LL |     fn alice<'a>(&self, _: &impl Trait) {}
   |                             ++++
help: alternatively, use a trait object to accept any type that implements `Trait`, accessing its methods at runtime using dynamic dispatch
   |
LL |     fn alice<'a>(&self, _: &dyn Trait) {}
   |                             +++

error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:18:23
   |
LL |     fn bob<'a>(_: &'a Trait) {}
   |                       ^^^^^
   |
help: use a new generic type parameter, constrained by `Trait`
   |
LL |     fn bob<'a, T: Trait>(_: &'a T) {}
   |              ++++++++++         ~
help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
   |
LL |     fn bob<'a>(_: &'a impl Trait) {}
   |                       ++++
help: alternatively, use a trait object to accept any type that implements `Trait`, accessing its methods at runtime using dynamic dispatch
   |
LL |     fn bob<'a>(_: &'a dyn Trait) {}
   |                       +++

error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:21:18
   |
LL |     fn cat() -> &Trait {
   |                  ^^^^^
   |
help: use `impl Trait` to return an opaque type, as long as you return a single underlying type
   |
LL |     fn cat() -> &impl Trait {
   |                  ++++
help: alternatively, you can return an owned trait object
   |
LL |     fn cat() -> Box<dyn Trait> {
   |                 ~~~~~~~~~~~~~~

error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:27:22
   |
LL |     fn dog<'a>() -> &Trait {
   |                      ^^^^^
   |
help: use `impl Trait` to return an opaque type, as long as you return a single underlying type
   |
LL |     fn dog<'a>() -> &impl Trait {
   |                      ++++
help: alternatively, you can return an owned trait object
   |
LL |     fn dog<'a>() -> Box<dyn Trait> {
   |                     ~~~~~~~~~~~~~~

error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:33:24
   |
LL |     fn kitten() -> &'a Trait {
   |                        ^^^^^
   |
help: use `impl Trait` to return an opaque type, as long as you return a single underlying type
   |
LL |     fn kitten() -> &'a impl Trait {
   |                        ++++
help: alternatively, you can return an owned trait object
   |
LL |     fn kitten() -> Box<dyn Trait> {
   |                    ~~~~~~~~~~~~~~

error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:39:27
   |
LL |     fn puppy<'a>() -> &'a Trait {
   |                           ^^^^^
   |
help: use `impl Trait` to return an opaque type, as long as you return a single underlying type
   |
LL |     fn puppy<'a>() -> &'a impl Trait {
   |                           ++++
help: alternatively, you can return an owned trait object
   |
LL |     fn puppy<'a>() -> Box<dyn Trait> {
   |                       ~~~~~~~~~~~~~~

error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:44:25
   |
LL |     fn parrot() -> &mut Trait {
   |                         ^^^^^
   |
help: use `impl Trait` to return an opaque type, as long as you return a single underlying type
   |
LL |     fn parrot() -> &mut impl Trait {
   |                         ++++
help: alternatively, you can return an owned trait object
   |
LL |     fn parrot() -> Box<dyn Trait> {
   |                    ~~~~~~~~~~~~~~

error: aborting due to 42 previous errors

Some errors have detailed explanations: E0106, E0261, E0782.
For more information about an error, try `rustc --explain E0106`.