reflect PartialOrd

crates/bevy_reflect/derive/src/container_attributes.rs

@@ -22,6 +22,7 @@ mod kw {
     syn::custom_keyword!(type_path);
     syn::custom_keyword!(Debug);
     syn::custom_keyword!(PartialEq);
+    syn::custom_keyword!(PartialOrd);
     syn::custom_keyword!(Hash);
     syn::custom_keyword!(Clone);
     syn::custom_keyword!(no_field_bounds);
@@ -33,6 +34,7 @@ mod kw {
 // Received via attributes like `#[reflect(PartialEq, Hash, ...)]`
 const DEBUG_ATTR: &str = "Debug";
 const PARTIAL_EQ_ATTR: &str = "PartialEq";
+const PARTIAL_ORD_ATTR: &str = "PartialOrd";
 const HASH_ATTR: &str = "Hash";
 
 // The traits listed below are not considered "special" (i.e. they use the `ReflectMyTrait` syntax)
@@ -180,6 +182,7 @@ pub(crate) struct ContainerAttributes {
     clone: TraitImpl,
     debug: TraitImpl,
     hash: TraitImpl,
+    partial_ord: TraitImpl,
     partial_eq: TraitImpl,
     from_reflect_attrs: FromReflectAttrs,
     type_path_attrs: TypePathAttrs,
@@ -248,6 +251,8 @@ impl ContainerAttributes {
             self.parse_debug(input)
         } else if lookahead.peek(kw::Hash) {
             self.parse_hash(input)
+        } else if lookahead.peek(kw::PartialOrd) {
+            self.parse_partial_ord(input)
         } else if lookahead.peek(kw::PartialEq) {
             self.parse_partial_eq(input)
         } else if lookahead.peek(Ident::peek_any) {
@@ -266,7 +271,7 @@ impl ContainerAttributes {
 
         if input.peek(token::Paren) {
             return Err(syn::Error::new(ident.span(), format!(
-                "only [{DEBUG_ATTR:?}, {PARTIAL_EQ_ATTR:?}, {HASH_ATTR:?}] may specify custom functions",
+                "only [{DEBUG_ATTR:?}, {PARTIAL_EQ_ATTR:?}, {PARTIAL_ORD_ATTR:?}, {HASH_ATTR:?}] may specify custom functions",
             )));
         }
 
@@ -342,6 +347,27 @@ impl ContainerAttributes {
         Ok(())
     }
 
+    /// Parse special `PartialOrd` registration.
+    ///
+    /// Examples:
+    /// - `#[reflect(PartialOrd)]`
+    /// - `#[reflect(PartialOrd(custom_partial_cmp_fn))]`
+    fn parse_partial_ord(&mut self, input: ParseStream) -> syn::Result<()> {
+        let ident = input.parse::<kw::PartialOrd>()?;
+
+        if input.peek(token::Paren) {
+            let content;
+            parenthesized!(content in input);
+            let path = content.parse::<Path>()?;
+            self.partial_ord
+                .merge(TraitImpl::Custom(path, ident.span))?;
+        } else {
+            self.partial_ord = TraitImpl::Implemented(ident.span);
+        }
+
+        Ok(())
+    }
+
     /// Parse special `Hash` registration.
     ///
     /// Examples:
@@ -546,6 +572,33 @@ impl ContainerAttributes {
         }
     }
 
+    /// Returns the implementation of `PartialReflect::reflect_partial_cmp` as a `TokenStream`.
+    ///
+    /// If `PartialOrd` was not registered, returns `None`.
+    pub fn get_partial_ord_impl(
+        &self,
+        bevy_reflect_path: &Path,
+    ) -> Option<proc_macro2::TokenStream> {
+        match &self.partial_ord {
+            &TraitImpl::Implemented(span) => Some(quote_spanned! {span=>
+                fn reflect_partial_cmp(&self, value: &dyn #bevy_reflect_path::PartialReflect) -> #FQOption<::core::cmp::Ordering> {
+                    let value = <dyn #bevy_reflect_path::PartialReflect>::try_downcast_ref::<Self>(value);
+                    if let #FQOption::Some(value) = value {
+                        ::core::cmp::PartialOrd::partial_cmp(self, value)
+                    } else {
+                        #FQOption::None
+                    }
+                }
+            }),
+            &TraitImpl::Custom(ref impl_fn, span) => Some(quote_spanned! {span=>
+                fn reflect_partial_cmp(&self, value: &dyn #bevy_reflect_path::PartialReflect) -> #FQOption<::core::cmp::Ordering> {
+                    #impl_fn(self, value)
+                }
+            }),
+            TraitImpl::NotImplemented => None,
+        }
+    }
+
     /// Returns the implementation of `PartialReflect::debug` as a `TokenStream`.
     ///
     /// If `Debug` was not registered, returns `None`.

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

@@ -83,6 +83,7 @@ pub fn common_partial_reflect_methods(
     meta: &ReflectMeta,
     default_partial_eq_delegate: impl FnOnce() -> Option<proc_macro2::TokenStream>,
     default_hash_delegate: impl FnOnce() -> Option<proc_macro2::TokenStream>,
+    default_partial_ord_delegate: impl FnOnce() -> Option<proc_macro2::TokenStream>,
 ) -> proc_macro2::TokenStream {
     let bevy_reflect_path = meta.bevy_reflect_path();
 
@@ -113,6 +114,19 @@ pub fn common_partial_reflect_methods(
                 }
             })
         });
+    let partial_ord_fn = meta
+        .attrs()
+        .get_partial_ord_impl(bevy_reflect_path)
+        .or_else(move || {
+            let default_delegate = default_partial_ord_delegate();
+            default_delegate.map(|func| {
+                quote! {
+                    fn reflect_partial_cmp(&self, value: &dyn #bevy_reflect_path::PartialReflect) -> #FQOption<::core::cmp::Ordering> {
+                        (#func)(self, value)
+                    }
+                }
+            })
+        });
 
     quote! {
         #[inline]
@@ -151,6 +165,8 @@ pub fn common_partial_reflect_methods(
 
         #partial_eq_fn
 
+        #partial_ord_fn
+
         #debug_fn
     }
 }

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

@@ -64,6 +64,7 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> proc_macro2::TokenStream
         reflect_enum.meta(),
         || Some(quote!(#bevy_reflect_path::enum_partial_eq)),
         || Some(quote!(#bevy_reflect_path::enum_hash)),
+        || None,
     );
     let clone_fn = reflect_enum.get_clone_impl();
 

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

@@ -30,7 +30,7 @@ pub(crate) fn impl_opaque(meta: &ReflectMeta) -> proc_macro2::TokenStream {
 
     let type_path_impl = impl_type_path(meta);
     let full_reflect_impl = impl_full_reflect(&where_clause_options);
-    let common_methods = common_partial_reflect_methods(meta, || None, || None);
+    let common_methods = common_partial_reflect_methods(meta, || None, || None, || None);
     let clone_fn = meta.attrs().get_clone_impl(bevy_reflect_path);
 
     let apply_impl = if let Some(remote_ty) = meta.remote_ty() {

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

@@ -42,6 +42,7 @@ pub(crate) fn impl_struct(reflect_struct: &ReflectStruct) -> proc_macro2::TokenS
         reflect_struct.meta(),
         || Some(quote!(#bevy_reflect_path::struct_partial_eq)),
         || None,
+        || None,
     );
     let clone_fn = reflect_struct.get_clone_impl();
 

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

@@ -32,6 +32,7 @@ pub(crate) fn impl_tuple_struct(reflect_struct: &ReflectStruct) -> proc_macro2::
         reflect_struct.meta(),
         || Some(quote!(#bevy_reflect_path::tuple_struct_partial_eq)),
         || None,
+        || None,
     );
     let clone_fn = reflect_struct.get_clone_impl();
 

crates/bevy_reflect/derive/src/lib.rs

@@ -171,6 +171,11 @@ fn match_reflect_impls(ast: DeriveInput, source: ReflectImplSource) -> TokenStre
 ///   A custom implementation may be provided using `#[reflect(PartialEq(my_partial_eq_func))]` where
 ///   `my_partial_eq_func` is the path to a function matching the signature:
 ///   `(&Self, value: &dyn #bevy_reflect_path::Reflect) -> bool`.
+/// * `#[reflect(PartialOrd)]` will let the implementation of `PartialReflect::reflect_partial_cmp`
+///   to rely on the type's [`PartialOrd`] implementation.
+///   A custom implementation may be provided using `#[reflect(PartialOrd(my_partial_cmp_fn))]` where
+///   `my_partial_cmp_fn` is the path to a function matching the signature:
+///   `(&Self, value: &dyn #bevy_reflect_path::PartialReflect) -> Option<::core::cmp::Ordering>`.
 /// * `#[reflect(Hash)]` will force the implementation of `Reflect::reflect_hash` to rely on
 ///   the type's [`Hash`] implementation.
 ///   A custom implementation may be provided using `#[reflect(Hash(my_hash_func))]` where

crates/bevy_reflect/src/impls/alloc/string.rs

@@ -9,6 +9,7 @@ impl_reflect_opaque!(::alloc::string::String(
     Debug,
     Hash,
     PartialEq,
+    PartialOrd,
     Serialize,
     Deserialize,
     Default

crates/bevy_reflect/src/impls/core/net.rs

@@ -6,6 +6,7 @@ impl_reflect_opaque!(::core::net::SocketAddr(
     Debug,
     Hash,
     PartialEq,
+    PartialOrd,
     Serialize,
     Deserialize
 ));

crates/bevy_reflect/src/impls/core/num.rs

@@ -6,6 +6,7 @@ impl_reflect_opaque!(::core::num::NonZeroI128(
     Debug,
     Hash,
     PartialEq,
+    PartialOrd,
     Serialize,
     Deserialize
 ));
@@ -14,6 +15,7 @@ impl_reflect_opaque!(::core::num::NonZeroU128(
     Debug,
     Hash,
     PartialEq,
+    PartialOrd,
     Serialize,
     Deserialize
 ));
@@ -22,6 +24,7 @@ impl_reflect_opaque!(::core::num::NonZeroIsize(
     Debug,
     Hash,
     PartialEq,
+    PartialOrd,
     Serialize,
     Deserialize
 ));
@@ -30,6 +33,7 @@ impl_reflect_opaque!(::core::num::NonZeroUsize(
     Debug,
     Hash,
     PartialEq,
+    PartialOrd,
     Serialize,
     Deserialize
 ));
@@ -38,6 +42,7 @@ impl_reflect_opaque!(::core::num::NonZeroI64(
     Debug,
     Hash,
     PartialEq,
+    PartialOrd,
     Serialize,
     Deserialize
 ));
@@ -46,6 +51,7 @@ impl_reflect_opaque!(::core::num::NonZeroU64(
     Debug,
     Hash,
     PartialEq,
+    PartialOrd,
     Serialize,
     Deserialize
 ));
@@ -54,6 +60,7 @@ impl_reflect_opaque!(::core::num::NonZeroU32(
     Debug,
     Hash,
     PartialEq,
+    PartialOrd,
     Serialize,
     Deserialize
 ));
@@ -62,6 +69,7 @@ impl_reflect_opaque!(::core::num::NonZeroI32(
     Debug,
     Hash,
     PartialEq,
+    PartialOrd,
     Serialize,
     Deserialize
 ));
@@ -70,6 +78,7 @@ impl_reflect_opaque!(::core::num::NonZeroI16(
     Debug,
     Hash,
     PartialEq,
+    PartialOrd,
     Serialize,
     Deserialize
 ));
@@ -78,6 +87,7 @@ impl_reflect_opaque!(::core::num::NonZeroU16(
     Debug,
     Hash,
     PartialEq,
+    PartialOrd,
     Serialize,
     Deserialize
 ));
@@ -86,6 +96,7 @@ impl_reflect_opaque!(::core::num::NonZeroU8(
     Debug,
     Hash,
     PartialEq,
+    PartialOrd,
     Serialize,
     Deserialize
 ));
@@ -94,6 +105,7 @@ impl_reflect_opaque!(::core::num::NonZeroI8(
     Debug,
     Hash,
     PartialEq,
+    PartialOrd,
     Serialize,
     Deserialize
 ));