tests/ui/impl-trait/dyn-incompatible-trait-in-return-position-dyn-trait.stderr

error[E0038]: the trait `DynIncompatible` is not dyn compatible
  --> $DIR/dyn-incompatible-trait-in-return-position-dyn-trait.rs:22:13
   |
LL | fn car() -> dyn DynIncompatible {
   |             ^^^^^^^^^^^^^^^^^^^ `DynIncompatible` is not dyn compatible
   |
note: for a trait to be dyn compatible it needs to allow building a vtable
      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
  --> $DIR/dyn-incompatible-trait-in-return-position-dyn-trait.rs:4:8
   |
LL | trait DynIncompatible {
   |       --------------- this trait is not dyn compatible...
LL |     fn foo() -> Self;
   |        ^^^ ...because associated function `foo` has no `self` parameter
   = help: the following types implement `DynIncompatible`:
             A
             B
           consider defining an enum where each variant holds one of these types,
           implementing `DynIncompatible` for this new enum and using it instead
help: consider turning `foo` into a method by giving it a `&self` argument
   |
LL |     fn foo(&self) -> Self;
   |            +++++
help: alternatively, consider constraining `foo` so it does not apply to trait objects
   |
LL |     fn foo() -> Self where Self: Sized;
   |                      +++++++++++++++++

error[E0746]: return type cannot be a trait object without pointer indirection
  --> $DIR/dyn-incompatible-trait-in-return-position-dyn-trait.rs:22:13
   |
LL | fn car() -> dyn DynIncompatible {
   |             ^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
   |
help: consider returning an `impl Trait` instead of a `dyn Trait`
   |
LL - fn car() -> dyn DynIncompatible {
LL + fn car() -> impl DynIncompatible {
   |
help: alternatively, box the return type, and wrap all of the returned values in `Box::new`
   |
LL ~ fn car() -> Box<dyn DynIncompatible> {
LL |
...
LL |     if true {
LL ~         return Box::new(A);
LL |     }
LL ~     Box::new(B)
   |

error[E0038]: the trait `DynIncompatible` is not dyn compatible
  --> $DIR/dyn-incompatible-trait-in-return-position-dyn-trait.rs:32:17
   |
LL | fn cat() -> Box<dyn DynIncompatible> {
   |                 ^^^^^^^^^^^^^^^^^^^ `DynIncompatible` is not dyn compatible
   |
note: for a trait to be dyn compatible it needs to allow building a vtable
      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
  --> $DIR/dyn-incompatible-trait-in-return-position-dyn-trait.rs:4:8
   |
LL | trait DynIncompatible {
   |       --------------- this trait is not dyn compatible...
LL |     fn foo() -> Self;
   |        ^^^ ...because associated function `foo` has no `self` parameter
   = help: the following types implement `DynIncompatible`:
             A
             B
           consider defining an enum where each variant holds one of these types,
           implementing `DynIncompatible` for this new enum and using it instead
help: consider turning `foo` into a method by giving it a `&self` argument
   |
LL |     fn foo(&self) -> Self;
   |            +++++
help: alternatively, consider constraining `foo` so it does not apply to trait objects
   |
LL |     fn foo() -> Self where Self: Sized;
   |                      +++++++++++++++++

error[E0038]: the trait `DynIncompatible` is not dyn compatible
  --> $DIR/dyn-incompatible-trait-in-return-position-dyn-trait.rs:22:17
   |
LL | fn car() -> dyn DynIncompatible {
   |                 ^^^^^^^^^^^^^^^ `DynIncompatible` is not dyn compatible
   |
note: for a trait to be dyn compatible it needs to allow building a vtable
      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
  --> $DIR/dyn-incompatible-trait-in-return-position-dyn-trait.rs:4:8
   |
LL | trait DynIncompatible {
   |       --------------- this trait is not dyn compatible...
LL |     fn foo() -> Self;
   |        ^^^ ...because associated function `foo` has no `self` parameter
   = help: the following types implement `DynIncompatible`:
             A
             B
           consider defining an enum where each variant holds one of these types,
           implementing `DynIncompatible` for this new enum and using it instead
help: consider using an opaque type instead
   |
LL - fn car() -> dyn DynIncompatible {
LL + fn car() -> impl DynIncompatible {
   |
help: consider turning `foo` into a method by giving it a `&self` argument
   |
LL |     fn foo(&self) -> Self;
   |            +++++
help: alternatively, consider constraining `foo` so it does not apply to trait objects
   |
LL |     fn foo() -> Self where Self: Sized;
   |                      +++++++++++++++++

error[E0038]: the trait `DynIncompatible` is not dyn compatible
  --> $DIR/dyn-incompatible-trait-in-return-position-dyn-trait.rs:22:17
   |
LL | fn car() -> dyn DynIncompatible {
   |                 ^^^^^^^^^^^^^^^ `DynIncompatible` is not dyn compatible
   |
note: for a trait to be dyn compatible it needs to allow building a vtable
      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
  --> $DIR/dyn-incompatible-trait-in-return-position-dyn-trait.rs:4:8
   |
LL | trait DynIncompatible {
   |       --------------- this trait is not dyn compatible...
LL |     fn foo() -> Self;
   |        ^^^ ...because associated function `foo` has no `self` parameter
   = help: the following types implement `DynIncompatible`:
             A
             B
           consider defining an enum where each variant holds one of these types,
           implementing `DynIncompatible` for this new enum and using it instead
   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
help: consider using an opaque type instead
   |
LL - fn car() -> dyn DynIncompatible {
LL + fn car() -> impl DynIncompatible {
   |
help: consider turning `foo` into a method by giving it a `&self` argument
   |
LL |     fn foo(&self) -> Self;
   |            +++++
help: alternatively, consider constraining `foo` so it does not apply to trait objects
   |
LL |     fn foo() -> Self where Self: Sized;
   |                      +++++++++++++++++

error: aborting due to 5 previous errors

Some errors have detailed explanations: E0038, E0746.
For more information about an error, try `rustc --explain E0038`.