mirror of
https://github.com/bevyengine/bevy
synced 2024-12-27 13:33:08 +00:00
fd329c0426
# Objective > Rust 1.81 released the #[expect(...)] attribute, which works like #[allow(...)] but throws a warning if the lint isn't raised. This is preferred to #[allow(...)] because it tells us when it can be removed. - Adopts the parts of #15118 that are complete, and updates the branch so it can be merged. - There were a few conflicts, let me know if I misjudged any of 'em. Alice's [recommendation](https://github.com/bevyengine/bevy/issues/15059#issuecomment-2349263900) seems well-taken, let's do this crate by crate now that @BD103 has done the lion's share of this! (Relates to, but doesn't yet completely finish #15059.) Crates this _doesn't_ cover: - bevy_input - bevy_gilrs - bevy_window - bevy_winit - bevy_state - bevy_render - bevy_picking - bevy_core_pipeline - bevy_sprite - bevy_text - bevy_pbr - bevy_ui - bevy_gltf - bevy_gizmos - bevy_dev_tools - bevy_internal - bevy_dylib --------- Co-authored-by: BD103 <59022059+BD103@users.noreply.github.com> Co-authored-by: Ben Frankel <ben.frankel7@gmail.com> Co-authored-by: Antony <antony.m.3012@gmail.com>
62 lines
2.4 KiB
Rust
62 lines
2.4 KiB
Rust
//! Contains code related specifically to Bevy's type registration.
|
|
|
|
use crate::derive_data::ReflectMeta;
|
|
use crate::serialization::SerializationDataDef;
|
|
use crate::utility::WhereClauseOptions;
|
|
use quote::quote;
|
|
use syn::Type;
|
|
|
|
/// Creates the `GetTypeRegistration` impl for the given type data.
|
|
pub(crate) fn impl_get_type_registration<'a>(
|
|
meta: &ReflectMeta,
|
|
where_clause_options: &WhereClauseOptions,
|
|
serialization_data: Option<&SerializationDataDef>,
|
|
type_dependencies: Option<impl Iterator<Item = &'a Type>>,
|
|
) -> proc_macro2::TokenStream {
|
|
let type_path = meta.type_path();
|
|
let bevy_reflect_path = meta.bevy_reflect_path();
|
|
let registration_data = meta.attrs().idents();
|
|
|
|
let type_deps_fn = type_dependencies.map(|deps| {
|
|
quote! {
|
|
#[inline(never)]
|
|
fn register_type_dependencies(registry: &mut #bevy_reflect_path::TypeRegistry) {
|
|
#(<#deps as #bevy_reflect_path::__macro_exports::RegisterForReflection>::__register(registry);)*
|
|
}
|
|
}
|
|
});
|
|
|
|
let (impl_generics, ty_generics, where_clause) = type_path.generics().split_for_impl();
|
|
let where_reflect_clause = where_clause_options.extend_where_clause(where_clause);
|
|
|
|
let from_reflect_data = if meta.from_reflect().should_auto_derive() {
|
|
Some(quote! {
|
|
registration.insert::<#bevy_reflect_path::ReflectFromReflect>(#bevy_reflect_path::FromType::<Self>::from_type());
|
|
})
|
|
} else {
|
|
None
|
|
};
|
|
|
|
let serialization_data = serialization_data.map(|data| {
|
|
let serialization_data = data.as_serialization_data(bevy_reflect_path);
|
|
quote! {
|
|
registration.insert::<#bevy_reflect_path::serde::SerializationData>(#serialization_data);
|
|
}
|
|
});
|
|
|
|
quote! {
|
|
#[allow(unused_mut)]
|
|
impl #impl_generics #bevy_reflect_path::GetTypeRegistration for #type_path #ty_generics #where_reflect_clause {
|
|
fn get_type_registration() -> #bevy_reflect_path::TypeRegistration {
|
|
let mut registration = #bevy_reflect_path::TypeRegistration::of::<Self>();
|
|
registration.insert::<#bevy_reflect_path::ReflectFromPtr>(#bevy_reflect_path::FromType::<Self>::from_type());
|
|
#from_reflect_data
|
|
#serialization_data
|
|
#(registration.insert::<#registration_data>(#bevy_reflect_path::FromType::<Self>::from_type());)*
|
|
registration
|
|
}
|
|
|
|
#type_deps_fn
|
|
}
|
|
}
|
|
}
|