Added remote field assertions

Author: MrGVSV

crates/bevy_reflect/bevy_reflect_derive/src/remote.rs

@@ -1,9 +1,14 @@
-use crate::{from_reflect, impls, ReflectDerive, REFLECT_ATTRIBUTE_NAME};
+use crate::derive_data::EnumVariantFields;
+use crate::{
+    derive_data::StructField, from_reflect, impls, utility::ident_or_index, ReflectDerive,
+    REFLECT_ATTRIBUTE_NAME,
+};
 use proc_macro::TokenStream;
-use quote::quote;
+use proc_macro2::Ident;
+use quote::{format_ident, quote};
 use syn::parse::{Parse, ParseStream};
 use syn::spanned::Spanned;
-use syn::{parse_macro_input, DeriveInput, ExprPath, PathArguments, Token, TypePath};
+use syn::{parse_macro_input, DeriveInput, ExprPath, Generics, PathArguments, Token, TypePath};
 
 /// Generates the remote wrapper type and implements all the necessary traits.
 pub(crate) fn reflect_remote(args: TokenStream, input: TokenStream) -> TokenStream {
@@ -31,14 +36,40 @@ pub(crate) fn reflect_remote(args: TokenStream, input: TokenStream) -> TokenStre
         None
     };
 
-    let trait_impls = match derive_data {
-        ReflectDerive::Struct(struct_data) | ReflectDerive::UnitStruct(struct_data) => {
-            proc_macro2::TokenStream::from(impls::impl_struct(&struct_data))
-        }
-        ReflectDerive::TupleStruct(struct_data) => {
-            proc_macro2::TokenStream::from(impls::impl_tuple_struct(&struct_data))
-        }
-        ReflectDerive::Enum(meta) => proc_macro2::TokenStream::from(impls::impl_enum(&meta)),
+    let (trait_impls, assertions) = match derive_data {
+        ReflectDerive::Struct(struct_data) | ReflectDerive::UnitStruct(struct_data) => (
+            proc_macro2::TokenStream::from(impls::impl_struct(&struct_data)),
+            Some(generate_remote_field_assertions(
+                struct_data.fields(),
+                None,
+                struct_data.meta().generics(),
+            )),
+        ),
+        ReflectDerive::TupleStruct(struct_data) => (
+            proc_macro2::TokenStream::from(impls::impl_tuple_struct(&struct_data)),
+            Some(generate_remote_field_assertions(
+                struct_data.fields(),
+                None,
+                struct_data.meta().generics(),
+            )),
+        ),
+        ReflectDerive::Enum(enum_data) => (
+            proc_macro2::TokenStream::from(impls::impl_enum(&enum_data)),
+            enum_data
+                .variants()
+                .iter()
+                .map(|variant| match &variant.fields {
+                    EnumVariantFields::Named(fields) | EnumVariantFields::Unnamed(fields) => {
+                        Some(generate_remote_field_assertions(
+                            fields,
+                            Some(&variant.data.ident),
+                            enum_data.meta().generics(),
+                        ))
+                    }
+                    EnumVariantFields::Unit => None,
+                })
+                .collect(),
+        ),
         _ => {
             return syn::Error::new(ast.span(), "cannot reflect a remote value type")
                 .into_compile_error()
@@ -49,6 +80,8 @@ pub(crate) fn reflect_remote(args: TokenStream, input: TokenStream) -> TokenStre
     TokenStream::from(quote! {
         #wrapper_definition
 
+        #assertions
+
         #from_reflect_impl
 
         #trait_impls
@@ -96,6 +129,74 @@ fn generate_remote_wrapper(input: &DeriveInput, remote_ty: &TypePath) -> proc_ma
     }
 }
 
+/// Generates compile-time assertions for remote fields.
+///
+/// # Example
+///
+/// The following would fail to compile due to an incorrect `#[reflect(remote = "...")]` value.
+///
+/// ```ignore
+/// mod external_crate {
+///     pub struct TheirOuter {
+///         pub inner: TheirInner,
+///     }
+///     pub struct TheirInner(pub String);
+/// }
+///
+/// #[reflect_remote(external_crate::TheirOuter)]
+/// struct MyOuter {
+///     #[reflect(remote = "MyOuter")] // <- Note the mismatched type (it should be `MyInner`)
+///     pub inner: external_crate::TheirInner,
+/// }
+///
+/// #[reflect_remote(external_crate::TheirInner)]
+/// struct MyInner(pub String);
+/// ```
+fn generate_remote_field_assertions<'a>(
+    fields: &[StructField<'a>],
+    variant: Option<&Ident>,
+    generics: &Generics,
+) -> proc_macro2::TokenStream {
+    fields
+        .iter()
+        .filter(|field| field.attrs.remote.is_some())
+        .map(|field| {
+            let ident = if let Some(variant) = variant {
+                format_ident!(
+                    "{}__{}",
+                    variant,
+                    ident_or_index(field.data.ident.as_ref(), field.index)
+                )
+            } else {
+                field
+                    .data
+                    .ident
+                    .as_ref()
+                    .map(|ident| ident.clone())
+                    .unwrap_or_else(|| format_ident!("field_{}", field.index))
+            };
+
+            let (impl_generics, _, where_clause) = generics.split_for_impl();
+            let field_ty = &field.data.ty;
+            let remote_ty = field.attrs.remote.as_ref().unwrap();
+            let assertion_ident = format_ident!("assert__{}__is_valid_remote", ident);
+
+            quote! {
+                const _: () = {
+                    struct RemoteFieldAssertions;
+
+                    impl RemoteFieldAssertions {
+                        #[allow(non_snake_case)]
+                        fn #assertion_ident #impl_generics (#ident: #remote_ty) #where_clause {
+                            let _: #field_ty = #ident.0;
+                        }
+                    }
+                };
+            }
+        })
+        .collect()
+}
+
 /// A reflected type's remote type.
 ///
 /// This is a wrapper around [`TypePath`] that allows it to be paired with other remote-specific logic.

crates/bevy_reflect_compile_fail_tests/tests/reflect_remote/nested.fail.rs

@@ -31,4 +31,18 @@ mod incorrect_inner_type {
     struct MyInner<T: Reflect>(pub T);
 }
 
+mod mismatched_remote_type {
+    use bevy_reflect::{reflect_remote, Reflect};
+
+    #[reflect_remote(super::external_crate::TheirOuter<T>)]
+    struct MyOuter<T: Reflect> {
+        // Reason: Should be `MyInner<T>`
+        #[reflect(remote = "MyOuter<T>")]
+        pub inner: super::external_crate::TheirInner<T>,
+    }
+
+    #[reflect_remote(super::external_crate::TheirInner<T>)]
+    struct MyInner<T: Reflect>(pub T);
+}
+
 fn main() {}

crates/bevy_reflect_compile_fail_tests/tests/reflect_remote/nested.fail.stderr

@@ -131,3 +131,16 @@ error[E0277]: the trait bound `TheirInner<T>: Reflect` is not satisfied
              (A, B, C, D, E, F, G)
            and $N others
    = note: this error originates in the attribute macro `reflect_remote` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0308]: mismatched types
+  --> tests/reflect_remote/nested.fail.rs:37:5
+   |
+37 |     #[reflect_remote(super::external_crate::TheirOuter<T>)]
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected struct `TheirInner`, found struct `TheirOuter`
+...
+41 |         pub inner: super::external_crate::TheirInner<T>,
+   |                    ------------------------------------ expected due to this
+   |
+   = note: expected struct `TheirInner<T>`
+              found struct `TheirOuter<T>`
+   = note: this error originates in the attribute macro `reflect_remote` (in Nightly builds, run with -Z macro-backtrace for more info)