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:56: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:66: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:70: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:76: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:87: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:98: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:112: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:118: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:124: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:135: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[E0515]: cannot return reference to temporary value --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:47:9 | LL | &mut Type | ^^^^^---- | | | | | temporary value created here | returns a reference to data owned by the current function error[E0515]: cannot return reference to temporary value --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:90:9 | LL | &mut Type | ^^^^^---- | | | | | temporary value created here | returns a reference to data owned by the current function error[E0515]: cannot return reference to temporary value --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:138:5 | LL | &mut Type | ^^^^^---- | | | | | temporary value created here | returns a reference to data owned by the current function error[E0782]: trait objects must include the `dyn` keyword --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:53:16 | LL | fn foo(_: &Trait); | ^^^^^ | help: use a new generic type parameter, constrained by `Trait` | LL | fn foo(_: &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]: trait objects must include the `dyn` keyword --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:56:19 | LL | fn bar(_: &'a Trait); | ^^^^^ | help: use a new generic type parameter, constrained by `Trait` | LL | fn bar(_: &'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]: trait objects must include the `dyn` keyword --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:60: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]: trait objects must include the `dyn` keyword --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:63: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]: trait objects must include the `dyn` keyword --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:66: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; | ~~~~~~~~~~~~~~ error[E0782]: trait objects must include the `dyn` keyword --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:70: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 { | ~~~~~~~~~~~~~~ error[E0782]: trait objects must include the `dyn` keyword --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:76: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 { | ~~~~~~~~~~~~~~ error[E0782]: trait objects must include the `dyn` keyword --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:82: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 { | ~~~~~~~~~~~~~~ error[E0782]: trait objects must include the `dyn` keyword --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:87: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 { | ~~~~~~~~~~~~~~ error[E0782]: trait objects must include the `dyn` keyword --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:95:12 | LL | fn foo(_: &Trait) {} | ^^^^^ | help: use a new generic type parameter, constrained by `Trait` | LL | fn foo(_: &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]: trait objects must include the `dyn` keyword --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:98:15 | LL | fn bar(_: &'a Trait) {} | ^^^^^ | help: use a new generic type parameter, constrained by `Trait` | LL | fn bar(_: &'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]: trait objects must include the `dyn` keyword --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:102: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]: trait objects must include the `dyn` keyword --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:105: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]: trait objects must include the `dyn` keyword --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:112: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 { | ~~~~~~~~~~~~~~ error[E0782]: trait objects must include the `dyn` keyword --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:118: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 { | ~~~~~~~~~~~~~~ error[E0782]: trait objects must include the `dyn` keyword --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:124: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 { | ~~~~~~~~~~~~~~ error[E0782]: trait objects must include the `dyn` keyword --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:130: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 { | ~~~~~~~~~~~~~~ error[E0782]: trait objects must include the `dyn` keyword --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:135: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 { | ~~~~~~~~~~~~~~ error[E0782]: trait objects must include the `dyn` keyword --> $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) {} | ++++++++++ ~ 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]: trait objects must include the `dyn` keyword --> $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(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]: trait objects must include the `dyn` keyword --> $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]: trait objects must include the `dyn` keyword --> $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]: trait objects must include the `dyn` keyword --> $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 { | ~~~~~~~~~~~~~~ error[E0782]: trait objects must include the `dyn` keyword --> $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 { | ~~~~~~~~~~~~~~ error[E0782]: trait objects must include the `dyn` keyword --> $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 { | ~~~~~~~~~~~~~~ error[E0782]: trait objects must include the `dyn` keyword --> $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 { | ~~~~~~~~~~~~~~ error[E0782]: trait objects must include the `dyn` keyword --> $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 { | ~~~~~~~~~~~~~~ error: aborting due to 45 previous errors Some errors have detailed explanations: E0106, E0261, E0515, E0782. For more information about an error, try `rustc --explain E0106`.