Reflect auto registration (#15030)

# Objective
This PR adds automatic registration of non-generic types annotated with
`#[derive(Reflect)]`.
Manually registering all reflect types can be error-prone, failing to
reflect during runtime if some type is not registered. #5781 fixed this
for nested types, improving ergonomics of using reflection dramatically,
but top-level types still need to be registered manually. This is
especially painful when prototyping and using inspector to change values
of components.
```rs
// from #5781
#[derive(Reflect)]
struct Foo(Bar);

#[derive(Reflect)]
struct Bar(Baz);

#[derive(Reflect)]
struct Baz(usize);

fn main() {
  // ...
  app.register_type::<Foo>() // <- can still forget to add this
  // ...
}
```

Fixes #3936.

## Solution
Automatically register all types that derive Reflect. This works for all
non-generic types, allowing users to just add `#[derive(Reflect)]` to
any compatible type and not think about where to register it.
```rs
fn main() {
  // No need to manually call .register_type::<Foo>()
  App::new()
    .add_plugins(DefaultPlugins)
    .add_systems(Startup, setup)
    .run();
}

#[derive(Reflect)]
pub struct Foo {
  a: usize,
}

fn setup(type_registry: Res<AppTypeRegistry>) {
  let type_registry = type_registry.read();
  assert!(type_registry.contains(TypeId::of::<Foo>()));
}
```

Automatic registration can be opted-out of by adding
`#[reflect(no_auto_register)]` reflect attribute to a type:
```rs
#[derive(Reflect)]
#[reflect(no_auto_register)]
pub struct Foo {
  a: usize,
}
```

Registration normally happens at app creation time, but `TypeRegistry`
itself has a new `register_derived_types` method to register all
collected types at any appropriate time:

```rs
#[derive(Reflect)]
struct Foo {
  name: Option<String>,
  value: i32
}

let mut type_registry = TypeRegistry::empty();
type_registry.register_derived_types();

assert!(type_registry.contains(TypeId::of::<Foo>()));
```

## Testing
- Tested by running `reflect` example and removing explicit type
registration, both on native and on `wasm32-unknown-unknown`.
- Added a doctest to `register_derived_types`

Impact on startup time is negligible: <40ms on debug wasm build and
<25ms on debug native build for 1614 registered types .

Wasm binary size comparison. All sizes are in KB as reported by `du` on
the modified `reflection` example.

| | **auto register, KiB** | **no auto register, KiB** | **abs diff,
KiB** | **% diff** |
| ---------------------------- | ---------------------- |
------------------------- | ----------------- | ---------- |
| wasm-release && wasm-bindgen | 27000 | 24224 | 2776 | 11.46% |
| wasm-opt -Oz | 16376 | 15340 | 1036 | 6.75% |
| wasm-opt -Os | 17728 | 16424 | 1304 | 7.94% |
| wasm-opt -Oz && gzip -c | 5620 | 5364 | 256 | 4.77% |


## Considerations
While automatic type registration improves ergonomics quite a bit for
projects that make heavy use of it, there are also some problems:
- Generic types can't be automatically registered. However, as long as
top-level reflect types don't need generics, recursive registration can
take care of the rest.
- Wasm bundle size increase is not insignificant. This is mostly due to
registering various engine types that weren't registered before. Size
overhead of automatic registration of types instead of manual is
relatively small, as can be see from this (somewhat outdated but still
relevant) table (see last 2 rows):

<details>

<summary>1000 simple structs with reflect wasm size comparison, no
engine types</summary>

| | auto register, KiB | no auto register, KiB | abs diff, KiB | % diff
|
| --------------------------------------------- | ------------- |
---------------- | -------- | ------ |
| wasm-release && wasm-bindgen | 27944 | 21644 | 6300 | 22.55% |
| wasm-release && wasm-bindgen +register_type | 28084 | 27764 | 320 |
1.14% |
| wasm-opt -Oz | 15612 | 13928 | 1684 | 10.79% |
| wasm-opt -Oz +register_type | 15676 | 15580 | 96 | 0.61% |
| wasm-release && wasm-bindgen (manual vs auto) | 27944 | 27764 | 180 |
0.64% |
| wasm-opt -Oz (manual vs auto) | 15612 | 15580 | 32 | 0.2% |

</details>

---------

Co-authored-by: Gino Valente <[email protected]>
Co-authored-by: Carter Anderson <[email protected]>

Author: 3 people

Cargo.toml

@@ -28,6 +28,8 @@ members = [
   "examples/mobile",
   # Examples of using Bevy on no_std platforms.
   "examples/no_std/*",
+  # Examples of compiling Bevy with automatic reflect type registration for platforms without `inventory` support.
+  "examples/reflection/auto_register_static",
   # Benchmarks
   "benches",
   # Internal tools that are not published.
@@ -159,6 +161,7 @@ default = [
   "hdr",
   "multi_threaded",
   "png",
+  "reflect_auto_register",
   "smaa_luts",
   "sysinfo_plugin",
   "tonemapping_luts",
@@ -548,6 +551,12 @@ reflect_functions = ["bevy_internal/reflect_functions"]
 # Enable documentation reflection
 reflect_documentation = ["bevy_internal/reflect_documentation"]
 
+# Enable automatic reflect registration
+reflect_auto_register = ["bevy_internal/reflect_auto_register"]
+
+# Enable automatic reflect registration without inventory. See `reflect::load_type_registrations` for more info.
+reflect_auto_register_static = ["bevy_internal/reflect_auto_register_static"]
+
 # Enable winit custom cursor support
 custom_cursor = ["bevy_internal/custom_cursor"]
 
@@ -2781,6 +2790,17 @@ description = "Demonstrates how to create and use type data"
 category = "Reflection"
 wasm = false
 
+[[example]]
+name = "auto_register_static"
+path = "examples/reflection/auto_register_static/src/lib.rs"
+doc-scrape-examples = true
+
+[package.metadata.example.auto_register_static]
+name = "Automatic types registration"
+description = "Demonstrates how to set up automatic reflect types registration for platforms without `inventory` support"
+category = "Reflection"
+wasm = false
+
 # Scene
 [[example]]
 name = "scene"

crates/bevy_app/Cargo.toml

@@ -22,6 +22,11 @@ reflect_functions = [
   "bevy_reflect/functions",
   "bevy_ecs/reflect_functions",
 ]
+reflect_auto_register = [
+  "bevy_reflect",
+  "bevy_reflect/auto_register",
+  "bevy_ecs/reflect_auto_register",
+]
 
 # Debugging Features
 

crates/bevy_app/src/app.rs

@@ -108,7 +108,12 @@ impl Default for App {
         {
             use bevy_ecs::observer::ObservedBy;
 
+            #[cfg(not(feature = "reflect_auto_register"))]
             app.init_resource::<AppTypeRegistry>();
+
+            #[cfg(feature = "reflect_auto_register")]
+            app.insert_resource(AppTypeRegistry::new_with_derived_types());
+
             app.register_type::<Name>();
             app.register_type::<ChildOf>();
             app.register_type::<Children>();

crates/bevy_app/src/hotpatch.rs

@@ -3,6 +3,8 @@ extern crate alloc;
 
 use alloc::sync::Arc;
 
+#[cfg(feature = "reflect_auto_register")]
+use bevy_ecs::schedule::IntoScheduleConfigs;
 use bevy_ecs::{
     change_detection::DetectChangesMut, event::EventWriter, system::ResMut, HotPatchChanges,
     HotPatched,
@@ -44,5 +46,14 @@ impl Plugin for HotPatchPlugin {
                     }
                 },
             );
+
+        #[cfg(feature = "reflect_auto_register")]
+        app.add_systems(
+            crate::First,
+            (move |registry: bevy_ecs::system::Res<bevy_ecs::reflect::AppTypeRegistry>| {
+                registry.write().register_derived_types();
+            })
+            .run_if(bevy_ecs::schedule::common_conditions::on_event::<HotPatched>),
+        );
     }
 }

crates/bevy_ecs/Cargo.toml

@@ -27,6 +27,7 @@ bevy_reflect = ["dep:bevy_reflect"]
 
 ## Extends reflection support to functions.
 reflect_functions = ["bevy_reflect", "bevy_reflect/functions"]
+reflect_auto_register = ["bevy_reflect", "bevy_reflect/auto_register"]
 
 ## Enables automatic backtrace capturing in BevyError
 backtrace = ["std"]

crates/bevy_ecs/src/reflect/mod.rs

@@ -47,6 +47,18 @@ impl DerefMut for AppTypeRegistry {
     }
 }
 
+impl AppTypeRegistry {
+    /// Creates [`AppTypeRegistry`] and automatically registers all types deriving [`Reflect`].
+    ///
+    /// See [`TypeRegistry::register_derived_types`] for more details.
+    #[cfg(feature = "reflect_auto_register")]
+    pub fn new_with_derived_types() -> Self {
+        let app_registry = AppTypeRegistry::default();
+        app_registry.write().register_derived_types();
+        app_registry
+    }
+}
+
 /// A [`Resource`] storing [`FunctionRegistry`] for
 /// function registrations relevant to a whole app.
 ///

crates/bevy_internal/Cargo.toml

@@ -300,6 +300,20 @@ reflect_functions = [
   "bevy_ecs/reflect_functions",
 ]
 
+# Enable automatic reflect registration using inventory.
+reflect_auto_register = [
+  "bevy_reflect/auto_register_inventory",
+  "bevy_app/reflect_auto_register",
+  "bevy_ecs/reflect_auto_register",
+]
+
+# Enable automatic reflect registration without inventory. See `reflect::load_type_registrations` for more info.
+reflect_auto_register_static = [
+  "bevy_reflect/auto_register_static",
+  "bevy_app/reflect_auto_register",
+  "bevy_ecs/reflect_auto_register",
+]
+
 # Enable documentation reflection
 reflect_documentation = ["bevy_reflect/documentation"]
 

crates/bevy_reflect/Cargo.toml

@@ -10,7 +10,7 @@ keywords = ["bevy"]
 rust-version = "1.85.0"
 
 [features]
-default = ["std", "smallvec", "debug"]
+default = ["std", "smallvec", "debug", "auto_register_inventory"]
 
 # Features
 
@@ -68,6 +68,22 @@ std = [
 ## on all platforms, including `no_std`.
 critical-section = ["bevy_platform/critical-section"]
 
+# Enables automatic reflect registration. Does nothing by itself, 
+# must select `auto_register_inventory` or `auto_register_static` to make it work.
+auto_register = []
+## Enables automatic reflect registration using inventory. Not supported on all platforms.
+auto_register_inventory = [
+  "auto_register",
+  "bevy_reflect_derive/auto_register_inventory",
+  "dep:inventory",
+]
+## Enable automatic reflect registration without inventory. This feature has precedence over `auto_register_inventory`.
+## See `load_type_registrations` for more info.
+auto_register_static = [
+  "auto_register",
+  "bevy_reflect_derive/auto_register_static",
+]
+
 ## Enables use of browser APIs.
 ## Note this is currently only applicable on `wasm32` architectures.
 web = ["bevy_platform/web", "uuid?/js"]
@@ -113,6 +129,9 @@ wgpu-types = { version = "26", features = [
   "serde",
 ], optional = true, default-features = false }
 
+# deps for automatic type registration
+inventory = { version = "0.3", optional = true }
+
 [dev-dependencies]
 ron = "0.10"
 rmp-serde = "1.1"

crates/bevy_reflect/derive/Cargo.toml

@@ -17,13 +17,23 @@ default = []
 documentation = []
 # Enables macro logic related to function reflection
 functions = []
+# Enables automatic reflect registration. Does nothing by itself, 
+# must select `auto_register_inventory` or `auto_register_static` to make it work.
+auto_register = []
+# Enables automatic reflection using inventory. Not supported on all platforms.
+auto_register_inventory = ["auto_register"]
+# Enables automatic reflection on platforms not supported by inventory. See `load_type_registrations` for more info.
+auto_register_static = ["auto_register", "dep:uuid"]
 
 [dependencies]
 bevy_macro_utils = { path = "../../bevy_macro_utils", version = "0.17.0-dev" }
 indexmap = "2.0"
 proc-macro2 = "1.0"
 quote = "1.0"
 syn = { version = "2.0", features = ["full", "extra-traits"] }
+uuid = { version = "1.13.1", default-features = false, features = [
+  "v4",
+], optional = true }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 # TODO: Assuming all wasm builds are for the browser. Require `no_std` support to break assumption.

crates/bevy_reflect/derive/src/container_attributes.rs

@@ -25,6 +25,7 @@ mod kw {
     syn::custom_keyword!(Hash);
     syn::custom_keyword!(Clone);
     syn::custom_keyword!(no_field_bounds);
+    syn::custom_keyword!(no_auto_register);
     syn::custom_keyword!(opaque);
 }
 
@@ -184,6 +185,7 @@ pub(crate) struct ContainerAttributes {
     type_path_attrs: TypePathAttrs,
     custom_where: Option<WhereClause>,
     no_field_bounds: bool,
+    no_auto_register: bool,
     custom_attributes: CustomAttributes,
     is_opaque: bool,
     idents: Vec<Ident>,
@@ -240,6 +242,8 @@ impl ContainerAttributes {
             self.parse_no_field_bounds(input)
         } else if lookahead.peek(kw::Clone) {
             self.parse_clone(input)
+        } else if lookahead.peek(kw::no_auto_register) {
+            self.parse_no_auto_register(input)
         } else if lookahead.peek(kw::Debug) {
             self.parse_debug(input)
         } else if lookahead.peek(kw::Hash) {
@@ -378,6 +382,16 @@ impl ContainerAttributes {
         Ok(())
     }
 
+    /// Parse `no_auto_register` attribute.
+    ///
+    /// Examples:
+    /// - `#[reflect(no_auto_register)]`
+    fn parse_no_auto_register(&mut self, input: ParseStream) -> syn::Result<()> {
+        input.parse::<kw::no_auto_register>()?;
+        self.no_auto_register = true;
+        Ok(())
+    }
+
     /// Parse `where` attribute.
     ///
     /// Examples:
@@ -583,6 +597,12 @@ impl ContainerAttributes {
         self.no_field_bounds
     }
 
+    /// Returns true if the `no_auto_register` attribute was found on this type.
+    #[cfg(feature = "auto_register")]
+    pub fn no_auto_register(&self) -> bool {
+        self.no_auto_register
+    }
+
     /// Returns true if the `opaque` attribute was found on this type.
     pub fn is_opaque(&self) -> bool {
         self.is_opaque