Add support for remote reflection of value types

Author: MrGVSV

crates/bevy_reflect/derive/src/derive_data.rs

@@ -47,6 +47,8 @@ pub(crate) struct ReflectMeta<'a> {
     attrs: ContainerAttributes,
     /// The path to this type.
     type_path: ReflectTypePath<'a>,
+    /// The optional remote type to use instead of the actual type.
+    remote_ty: Option<RemoteType<'a>>,
     /// A cached instance of the path to the `bevy_reflect` crate.
     bevy_reflect_path: Path,
     /// The documentation for this type, if any
@@ -71,7 +73,6 @@ pub(crate) struct ReflectStruct<'a> {
     meta: ReflectMeta<'a>,
     serialization_data: Option<SerializationDataDef>,
     fields: Vec<StructField<'a>>,
-    remote_ty: Option<RemoteType<'a>>,
 }
 
 /// Enum data used by derive macros for `Reflect` and `FromReflect`.
@@ -90,7 +91,6 @@ pub(crate) struct ReflectStruct<'a> {
 pub(crate) struct ReflectEnum<'a> {
     meta: ReflectMeta<'a>,
     variants: Vec<EnumVariant<'a>>,
-    remote_ty: Option<RemoteType<'a>>,
 }
 
 /// Represents a field on a struct or tuple struct.
@@ -331,7 +331,6 @@ impl<'a> ReflectDerive<'a> {
                     meta,
                     serialization_data: SerializationDataDef::new(&fields)?,
                     fields,
-                    remote_ty: None,
                 };
 
                 match data.fields {
@@ -343,11 +342,7 @@ impl<'a> ReflectDerive<'a> {
             Data::Enum(data) => {
                 let variants = Self::collect_enum_variants(&data.variants)?;
 
-                let reflect_enum = ReflectEnum {
-                    meta,
-                    variants,
-                    remote_ty: None,
-                };
+                let reflect_enum = ReflectEnum { meta, variants };
                 Ok(Self::Enum(reflect_enum))
             }
             Data::Union(..) => Err(syn::Error::new(
@@ -365,23 +360,25 @@ impl<'a> ReflectDerive<'a> {
     pub fn set_remote(&mut self, remote_ty: Option<RemoteType<'a>>) {
         match self {
             Self::Struct(data) | Self::TupleStruct(data) | Self::UnitStruct(data) => {
-                data.remote_ty = remote_ty;
+                data.meta.remote_ty = remote_ty;
             }
             Self::Enum(data) => {
-                data.remote_ty = remote_ty;
+                data.meta.remote_ty = remote_ty;
+            }
+            Self::Value(meta) => {
+                meta.remote_ty = remote_ty;
             }
-            _ => panic!("cannot create a reflected value type for a remote type"),
         }
     }
 
     /// Get the remote type path, if any.
     pub fn remote_ty(&self) -> Option<RemoteType> {
         match self {
             Self::Struct(data) | Self::TupleStruct(data) | Self::UnitStruct(data) => {
-                data.remote_ty()
+                data.meta.remote_ty()
             }
-            Self::Enum(data) => data.remote_ty(),
-            Self::Value(_) => None,
+            Self::Enum(data) => data.meta.remote_ty(),
+            Self::Value(meta) => meta.remote_ty(),
         }
     }
 
@@ -475,6 +472,7 @@ impl<'a> ReflectMeta<'a> {
         Self {
             attrs,
             type_path,
+            remote_ty: None,
             bevy_reflect_path: utility::get_bevy_reflect_path(),
             #[cfg(feature = "documentation")]
             docs: Default::default(),
@@ -508,6 +506,16 @@ impl<'a> ReflectMeta<'a> {
         &self.type_path
     }
 
+    /// Get the remote type path, if any.
+    pub fn remote_ty(&self) -> Option<RemoteType> {
+        self.remote_ty
+    }
+
+    /// Whether this reflected type represents a remote type or not.
+    pub fn is_remote_wrapper(&self) -> bool {
+        self.remote_ty.is_some()
+    }
+
     /// The cached `bevy_reflect` path.
     pub fn bevy_reflect_path(&self) -> &Path {
         &self.bevy_reflect_path
@@ -595,17 +603,6 @@ impl<'a> ReflectStruct<'a> {
         self.serialization_data.as_ref()
     }
 
-    /// Whether this reflected struct represents a remote type or not.
-    pub fn is_remote_wrapper(&self) -> bool {
-        self.remote_ty.is_some()
-    }
-
-    #[allow(dead_code)]
-    /// Get the remote type path, if any.
-    pub fn remote_ty(&self) -> Option<RemoteType<'a>> {
-        self.remote_ty
-    }
-
     /// Returns the `GetTypeRegistration` impl as a `TokenStream`.
     ///
     /// Returns a specific implementation for structs and this method should be preferred over the generic [`get_type_registration`](ReflectMeta) method
@@ -705,22 +702,12 @@ impl<'a> ReflectEnum<'a> {
         &self.meta
     }
 
-    /// Whether this reflected enum represents a remote type or not.
-    pub fn is_remote_wrapper(&self) -> bool {
-        self.remote_ty.is_some()
-    }
-
-    #[allow(dead_code)]
-    /// Get the remote type path, if any.
-    pub fn remote_ty(&self) -> Option<RemoteType<'a>> {
-        self.remote_ty
-    }
-
     /// Returns the given ident as a qualified unit variant of this enum.
     ///
     /// This takes into account the remote type, if any.
     pub fn get_unit(&self, variant: &Ident) -> proc_macro2::TokenStream {
         let name = self
+            .meta
             .remote_ty
             .map(|path| match path.as_expr_path() {
                 Ok(path) => path.to_token_stream(),

crates/bevy_reflect/derive/src/from_reflect.rs

@@ -52,7 +52,7 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> proc_macro2::TokenStream
         ..
     } = FromReflectVariantBuilder::new(reflect_enum).build(&ref_value);
 
-    let match_branches = if reflect_enum.is_remote_wrapper() {
+    let match_branches = if reflect_enum.meta().is_remote_wrapper() {
         quote! {
             #(#variant_names => #fqoption::Some(Self(#variant_constructors)),)*
         }
@@ -104,6 +104,7 @@ fn impl_struct_internal(
     let fqoption = FQOption.into_token_stream();
 
     let struct_path = reflect_struct.meta().type_path();
+    let remote_ty = reflect_struct.meta().remote_ty();
     let bevy_reflect_path = reflect_struct.meta().bevy_reflect_path();
 
     let ref_struct = Ident::new("__ref_struct", Span::call_site());
@@ -122,7 +123,7 @@ fn impl_struct_internal(
     let __this = Ident::new("__this", Span::call_site());
 
     // The reflected type: either `Self` or a remote type
-    let (reflect_ty, constructor, retval) = if let Some(remote_ty) = reflect_struct.remote_ty() {
+    let (reflect_ty, constructor, retval) = if let Some(remote_ty) = remote_ty {
         let constructor = match remote_ty.as_expr_path() {
             Ok(path) => path,
             Err(err) => return err.into_compile_error(),

crates/bevy_reflect/derive/src/impls/common.rs

@@ -7,15 +7,14 @@ use crate::{derive_data::ReflectMeta, utility::WhereClauseOptions};
 pub fn impl_full_reflect(
     meta: &ReflectMeta,
     where_clause_options: &WhereClauseOptions,
-    is_remote_wrapper: bool,
 ) -> proc_macro2::TokenStream {
     let bevy_reflect_path = meta.bevy_reflect_path();
     let type_path = meta.type_path();
 
     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 any_impls = if is_remote_wrapper {
+    let any_impls = if meta.is_remote_wrapper() {
         quote! {
             #[inline]
             fn into_any(self: #FQBox<Self>) -> #FQBox<dyn #FQAny> {

crates/bevy_reflect/derive/src/impls/enums.rs

@@ -9,7 +9,7 @@ use syn::{Fields, Path};
 pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> proc_macro2::TokenStream {
     let bevy_reflect_path = reflect_enum.meta().bevy_reflect_path();
     let enum_path = reflect_enum.meta().type_path();
-    let is_remote = reflect_enum.is_remote_wrapper();
+    let is_remote = reflect_enum.meta().is_remote_wrapper();
 
     // For `match self` expressions where self is a reference
     let match_this = if is_remote {
@@ -62,11 +62,7 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> proc_macro2::TokenStream
     );
 
     let type_path_impl = impl_type_path(reflect_enum.meta());
-    let full_reflect_impl = impl_full_reflect(
-        reflect_enum.meta(),
-        &where_clause_options,
-        reflect_enum.is_remote_wrapper(),
-    );
+    let full_reflect_impl = impl_full_reflect(reflect_enum.meta(), &where_clause_options);
     let common_methods = common_partial_reflect_methods(
         reflect_enum.meta(),
         || Some(quote!(#bevy_reflect_path::enum_partial_eq)),

crates/bevy_reflect/derive/src/impls/structs.rs

@@ -39,11 +39,7 @@ pub(crate) fn impl_struct(reflect_struct: &ReflectStruct) -> proc_macro2::TokenS
     );
 
     let type_path_impl = impl_type_path(reflect_struct.meta());
-    let full_reflect_impl = impl_full_reflect(
-        reflect_struct.meta(),
-        &where_clause_options,
-        reflect_struct.is_remote_wrapper(),
-    );
+    let full_reflect_impl = impl_full_reflect(reflect_struct.meta(), &where_clause_options);
     let common_methods = common_partial_reflect_methods(
         reflect_struct.meta(),
         || Some(quote!(#bevy_reflect_path::struct_partial_eq)),

crates/bevy_reflect/derive/src/impls/tuple_structs.rs

@@ -29,11 +29,7 @@ pub(crate) fn impl_tuple_struct(reflect_struct: &ReflectStruct) -> proc_macro2::
     );
 
     let type_path_impl = impl_type_path(reflect_struct.meta());
-    let full_reflect_impl = impl_full_reflect(
-        reflect_struct.meta(),
-        &where_clause_options,
-        reflect_struct.is_remote_wrapper(),
-    );
+    let full_reflect_impl = impl_full_reflect(reflect_struct.meta(), &where_clause_options);
     let common_methods = common_partial_reflect_methods(
         reflect_struct.meta(),
         || Some(quote!(#bevy_reflect_path::tuple_struct_partial_eq)),

crates/bevy_reflect/derive/src/impls/values.rs

@@ -28,9 +28,26 @@ pub(crate) fn impl_value(meta: &ReflectMeta) -> proc_macro2::TokenStream {
     );
 
     let type_path_impl = impl_type_path(meta);
-    let full_reflect_impl = impl_full_reflect(meta, &where_clause_options, false);
+    let full_reflect_impl = impl_full_reflect(meta, &where_clause_options);
     let common_methods = common_partial_reflect_methods(meta, || None, || None);
 
+    let apply_impl = if let Some(remote_ty) = meta.remote_ty() {
+        let ty = remote_ty.type_path();
+        quote! {
+            if let #FQOption::Some(value) = <dyn #bevy_reflect_path::PartialReflect>::try_downcast_ref::<#ty>(value) {
+                *self = Self(#FQClone::clone(value));
+                return #FQResult::Ok(());
+            }
+        }
+    } else {
+        quote! {
+            if let #FQOption::Some(value) = <dyn #bevy_reflect_path::PartialReflect>::try_downcast_ref::<Self>(value) {
+                *self = #FQClone::clone(value);
+                return #FQResult::Ok(());
+            }
+        }
+    };
+
     #[cfg(not(feature = "functions"))]
     let function_impls = None::<proc_macro2::TokenStream>;
     #[cfg(feature = "functions")]
@@ -67,17 +84,14 @@ pub(crate) fn impl_value(meta: &ReflectMeta) -> proc_macro2::TokenStream {
                 &mut self,
                 value: &dyn #bevy_reflect_path::PartialReflect
             ) -> #FQResult<(), #bevy_reflect_path::ApplyError> {
-                if let #FQOption::Some(value) = <dyn #bevy_reflect_path::PartialReflect>::try_downcast_ref::<Self>(value) {
-                    *self = #FQClone::clone(value);
-                } else {
-                    return #FQResult::Err(
-                        #bevy_reflect_path::ApplyError::MismatchedTypes {
-                            from_type: ::core::convert::Into::into(#bevy_reflect_path::DynamicTypePath::reflect_type_path(value)),
-                            to_type: ::core::convert::Into::into(<Self as #bevy_reflect_path::TypePath>::type_path()),
-                        }
-                    );
-                }
-                #FQResult::Ok(())
+                #apply_impl
+
+                #FQResult::Err(
+                    #bevy_reflect_path::ApplyError::MismatchedTypes {
+                        from_type: ::core::convert::Into::into(#bevy_reflect_path::DynamicTypePath::reflect_type_path(value)),
+                        to_type: ::core::convert::Into::into(<Self as #bevy_reflect_path::TypePath>::type_path()),
+                    }
+                )
             }
 
             #[inline]

crates/bevy_reflect/derive/src/remote.rs

@@ -1,7 +1,9 @@
 use crate::derive_data::{ReflectImplSource, ReflectProvenance, ReflectTraitToImpl};
 use crate::impls::impl_assertions;
 use crate::utility::ident_or_index;
-use crate::{from_reflect, impls, ReflectDerive, REFLECT_ATTRIBUTE_NAME};
+use crate::{
+    from_reflect, impls, ReflectDerive, REFLECT_ATTRIBUTE_NAME, REFLECT_VALUE_ATTRIBUTE_NAME,
+};
 use bevy_macro_utils::fq_std::FQOption;
 use proc_macro::TokenStream;
 use proc_macro2::{Ident, Span};
@@ -68,11 +70,14 @@ pub(crate) fn reflect_remote(args: TokenStream, input: TokenStream) -> TokenStre
                 None
             },
         ),
-        _ => {
-            return syn::Error::new(ast.span(), "cannot reflect a remote value type")
-                .into_compile_error()
-                .into()
-        }
+        ReflectDerive::Value(meta) => (
+            impls::impl_value(&meta),
+            if meta.from_reflect().should_auto_derive() {
+                Some(from_reflect::impl_value(&meta))
+            } else {
+                None
+            },
+        ),
     };
 
     TokenStream::from(quote! {
@@ -109,10 +114,10 @@ fn generate_remote_wrapper(input: &DeriveInput, remote_ty: &TypePath) -> proc_ma
     let vis = &input.vis;
     let ty_generics = &input.generics;
     let where_clause = &input.generics.where_clause;
-    let attrs = input
-        .attrs
-        .iter()
-        .filter(|attr| !attr.path().is_ident(REFLECT_ATTRIBUTE_NAME));
+    let attrs = input.attrs.iter().filter(|attr| {
+        !attr.path().is_ident(REFLECT_ATTRIBUTE_NAME)
+            && !attr.path().is_ident(REFLECT_VALUE_ATTRIBUTE_NAME)
+    });
 
     quote! {
         #(#attrs)*
@@ -402,12 +407,9 @@ fn generate_remote_definition_assertions(derive_data: &ReflectDerive) -> proc_ma
                 }
             }
         }
-        ReflectDerive::Value(meta) => {
-            return syn::Error::new(
-                meta.type_path().span(),
-                "cannot reflect a remote value type",
-            )
-            .into_compile_error()
+        ReflectDerive::Value(_) => {
+            // No assertions needed since there are no fields to check
+            proc_macro2::TokenStream::new()
         }
     };
 

crates/bevy_reflect/derive/src/struct_utility.rs

@@ -61,7 +61,7 @@ impl FieldAccessors {
     where
         F: FnMut(&StructField, proc_macro2::TokenStream) -> proc_macro2::TokenStream,
     {
-        let is_remote = reflect_struct.is_remote_wrapper();
+        let is_remote = reflect_struct.meta().is_remote_wrapper();
         reflect_struct
             .active_fields()
             .map(|field| {