bevy_reflect_derive 0.10.0 > 0.10.1 has a breaking change for recursion

[Aultus-defora]

Bevy version

0.10.1

If you cannot get Bevy to build or run on your machine, please include:

• the Rust version 1.70.0 (ec8a8a0ca 2023-04-25)
• MacOS Ventura 13.4

What you did

In 0.10.0 version struct and enum that could be recursive with #[cfg_attr(debug_assertions, derive(FromReflect, Reflect))] working,
but with 0.10.1 bevy_reflect_derive it does not even compile with a overflow evaluating the requirement RecurEnum: FromReflect

What went wrong

I expected the automatic update from 0.10.0 to 0.10.1 to not have breaking change
Wonder if the issue is that 'Reflect' was never intended to be used this way to begin with

Additional information

Other information that can be used to further reproduce or isolate the problem.
Here is the simplified code that used to compile in 0.10.0 but doesn't in 0.10.1

use bevy::{
    prelude::*,
    reflect::{FromReflect, Reflect},
};

#[cfg_attr(debug_assertions, derive(FromReflect, Reflect))]
enum RecurEnum {
    RecurStruct(RecurStruct),
    Const(f64)
}
#[cfg_attr(debug_assertions, derive(FromReflect, Reflect))]
pub struct RecurStruct {
    vector: Vec<RecurEnum>,
}

also old lock that allows this code to compile

Cargo.lock.txt

P.S. adding cargo tolm that makes the example work by forcing bevy_reflect_derive to be 0.10.0
Cargo.toml.txt

[MrGVSV]

Note: While the above example does seem to break between 0.10.0 and 0.10.1, this example is broken on both:

#[derive(Reflect, FromReflect)]
struct Foo {
  foo: Vec<Foo>
}

This indicates that the issue has possibly existed for longer. The fix would be to remove the generated self-referential where clause. However, this comes with difficulties due to generics and will require a thoughtful solution in order to capture all edge cases.

[MrGVSV]

I may have an idea to fix this. I'll see if I can get it working!

Edit: Seems to be working. I'll run a few more tests then post the PR.

[MrGVSV]

This should be fixed now with #9046 and #11597 merged.

For recursive types, you need to opt-out of field bounds using #[reflect(no_field_bounds)]:

#[derive(Reflect)]
#[reflect(no_field_bounds)]
struct Foo {
  foo: Vec<Foo>,
}

For generic recursive types, you may also need to use #[reflect(where T: FromReflect)] to re-bound your fields:

#[derive(Reflect)]
#[reflect(no_field_bounds)]
#[reflect(where T: FromReflect)]
struct Foo<T> {
  foo: Vec<Foo<T>>,
  t: T,
}