Improve reflection hygiene

Wrap impl-only macros inside unnamed constants.

crates/bevy_reflect/bevy_reflect_derive/src/lib.rs

@@ -244,15 +244,20 @@ pub fn derive_from_reflect(input: TokenStream) -> TokenStream {
         Err(err) => return err.into_compile_error().into(),
     };
 
-    match derive_data {
+    let from_reflect_impl = match derive_data {
         ReflectDerive::Struct(struct_data) | ReflectDerive::UnitStruct(struct_data) => {
             from_reflect::impl_struct(&struct_data)
         }
         ReflectDerive::TupleStruct(struct_data) => from_reflect::impl_tuple_struct(&struct_data),
         ReflectDerive::Enum(meta) => from_reflect::impl_enum(&meta),
         ReflectDerive::Value(meta) => from_reflect::impl_value(&meta),
-    }
-    .into()
+    };
+
+    TokenStream::from(quote! {
+        const _: () = {
+            #from_reflect_impl
+        };
+    })
 }
 
 /// Derives the `TypePath` trait, providing a stable alternative to [`std::any::type_name`].
@@ -278,21 +283,31 @@ pub fn derive_type_path(input: TokenStream) -> TokenStream {
         Err(err) => return err.into_compile_error().into(),
     };
 
-    impls::impl_type_path(
+    let type_path_impl = impls::impl_type_path(
         derive_data.meta(),
         // Use `WhereClauseOptions::new_value` here so we don't enforce reflection bounds
         &WhereClauseOptions::new_value(derive_data.meta()),
-    )
-    .into()
+    );
+
+    TokenStream::from(quote! {
+        const _: () = {
+            #type_path_impl
+        };
+    })
 }
 
 // From https://github.com/randomPoison/type-uuid
 #[proc_macro_derive(TypeUuid, attributes(uuid))]
 pub fn derive_type_uuid(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
-    type_uuid::type_uuid_derive(input)
-        .unwrap_or_else(syn::Error::into_compile_error)
-        .into()
+    let uuid_impl =
+        type_uuid::type_uuid_derive(input).unwrap_or_else(syn::Error::into_compile_error);
+
+    TokenStream::from(quote! {
+        const _: () = {
+            #uuid_impl
+        };
+    })
 }
 
 /// A macro that automatically generates type data for traits, which their implementors can then register.
@@ -404,8 +419,10 @@ pub fn impl_reflect_value(input: TokenStream) -> TokenStream {
     let from_reflect_impl = from_reflect::impl_value(&meta);
 
     TokenStream::from(quote! {
-        #reflect_impls
-        #from_reflect_impl
+        const _: () = {
+            #reflect_impls
+            #from_reflect_impl
+        };
     })
 }
 
@@ -449,7 +466,7 @@ pub fn impl_reflect_struct(input: TokenStream) -> TokenStream {
         Err(err) => return err.into_compile_error().into(),
     };
 
-    match derive_data {
+    let output = match derive_data {
         ReflectDerive::Struct(struct_data) => {
             if !struct_data.meta().type_path().has_custom_path() {
                 return syn::Error::new(
@@ -463,27 +480,30 @@ pub fn impl_reflect_struct(input: TokenStream) -> TokenStream {
             let impl_struct = impls::impl_struct(&struct_data);
             let impl_from_struct = from_reflect::impl_struct(&struct_data);
 
-            TokenStream::from(quote! {
+            quote! {
                 #impl_struct
                 #impl_from_struct
-            })
+            }
         }
         ReflectDerive::TupleStruct(..) => syn::Error::new(
             ast.span(),
             "impl_reflect_struct does not support tuple structs",
         )
-        .into_compile_error()
-        .into(),
+        .into_compile_error(),
         ReflectDerive::UnitStruct(..) => syn::Error::new(
             ast.span(),
             "impl_reflect_struct does not support unit structs",
         )
-        .into_compile_error()
-        .into(),
+        .into_compile_error(),
         _ => syn::Error::new(ast.span(), "impl_reflect_struct only supports structs")
-            .into_compile_error()
-            .into(),
-    }
+            .into_compile_error(),
+    };
+
+    TokenStream::from(quote! {
+        const _: () = {
+            #output
+        };
+    })
 }
 
 /// A macro used to generate a `FromReflect` trait implementation for the given type.
@@ -524,7 +544,14 @@ pub fn impl_from_reflect_value(input: TokenStream) -> TokenStream {
         }
     };
 
-    from_reflect::impl_value(&ReflectMeta::new(type_path, def.traits.unwrap_or_default())).into()
+    let from_reflect_impl =
+        from_reflect::impl_value(&ReflectMeta::new(type_path, def.traits.unwrap_or_default()));
+
+    TokenStream::from(quote! {
+        const _: () = {
+            #from_reflect_impl
+        };
+    })
 }
 
 /// A replacement for [deriving `TypePath`] for use on foreign types.
@@ -586,12 +613,24 @@ pub fn impl_type_path(input: TokenStream) -> TokenStream {
 
     let meta = ReflectMeta::new(type_path, ReflectTraits::default());
 
-    impls::impl_type_path(&meta, &WhereClauseOptions::new_value(&meta)).into()
+    let type_path_impl = impls::impl_type_path(&meta, &WhereClauseOptions::new_value(&meta));
+
+    TokenStream::from(quote! {
+        const _: () = {
+            #type_path_impl
+        };
+    })
 }
 
 /// Derives `TypeUuid` for the given type. This is used internally to implement `TypeUuid` on foreign types, such as those in the std. This macro should be used in the format of `<[Generic Params]> [Type (Path)], [Uuid (String Literal)]`.
 #[proc_macro]
 pub fn impl_type_uuid(input: TokenStream) -> TokenStream {
     let def = parse_macro_input!(input as type_uuid::TypeUuidDef);
-    type_uuid::gen_impl_type_uuid(def).into()
+    let uuid_impl = type_uuid::gen_impl_type_uuid(def);
+
+    TokenStream::from(quote! {
+        const _: () = {
+            #uuid_impl
+        };
+    })
 }