maximally relax bounds for all TypePath impls

Author: soqb

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

@@ -84,7 +84,7 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> TokenStream {
         },
     );
 
-    let type_path_impl = impl_type_path(reflect_enum.meta(), &where_clause_options);
+    let type_path_impl = impl_type_path(reflect_enum.meta());
 
     let get_type_registration_impl = reflect_enum
         .meta()

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

@@ -90,7 +90,7 @@ pub(crate) fn impl_struct(reflect_struct: &ReflectStruct) -> TokenStream {
         },
     );
 
-    let type_path_impl = impl_type_path(reflect_struct.meta(), &where_clause_options);
+    let type_path_impl = impl_type_path(reflect_struct.meta());
 
     let get_type_registration_impl = reflect_struct.get_type_registration(&where_clause_options);
 

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

@@ -83,7 +83,7 @@ pub(crate) fn impl_tuple_struct(reflect_struct: &ReflectStruct) -> TokenStream {
         },
     );
 
-    let type_path_impl = impl_type_path(reflect_struct.meta(), &where_clause_options);
+    let type_path_impl = impl_type_path(reflect_struct.meta());
 
     let (impl_generics, ty_generics, where_clause) = reflect_struct
         .meta()

crates/bevy_reflect/bevy_reflect_derive/src/impls/typed.rs

@@ -48,12 +48,10 @@ pub(crate) enum TypedProperty {
     TypePath,
 }
 
-pub(crate) fn impl_type_path(
-    meta: &ReflectMeta,
-    where_clause_options: &WhereClauseOptions,
-) -> proc_macro2::TokenStream {
+pub(crate) fn impl_type_path(meta: &ReflectMeta) -> proc_macro2::TokenStream {
     let type_path = meta.type_path();
     let bevy_reflect_path = meta.bevy_reflect_path();
+    let where_clause_options = WhereClauseOptions::type_path_bounds(meta);
 
     let (long_type_path, short_type_path) = if type_path.impl_is_generic() {
         let long_path_cell = static_type_cell(
@@ -101,7 +99,7 @@ pub(crate) fn impl_type_path(
     let (impl_generics, ty_generics, where_clause) = type_path.generics().split_for_impl();
 
     // Add Typed bound for each active field
-    let where_reflect_clause = extend_where_clause(where_clause, where_clause_options);
+    let where_reflect_clause = extend_where_clause(where_clause, &where_clause_options);
 
     quote! {
         #primitive_assert

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

@@ -32,7 +32,7 @@ pub(crate) fn impl_value(meta: &ReflectMeta) -> TokenStream {
         },
     );
 
-    let type_path_impl = impl_type_path(meta, &where_clause_options);
+    let type_path_impl = impl_type_path(meta);
 
     let (impl_generics, ty_generics, where_clause) = type_path.generics().split_for_impl();
     let where_reflect_clause = extend_where_clause(where_clause, &where_clause_options);

crates/bevy_reflect/bevy_reflect_derive/src/lib.rs

@@ -41,7 +41,6 @@ use syn::spanned::Spanned;
 use syn::{parse_macro_input, DeriveInput};
 use type_path::NamedTypePathDef;
 use type_uuid::TypeUuidDef;
-use utility::WhereClauseOptions;
 
 pub(crate) static REFLECT_ATTRIBUTE_NAME: &str = "reflect";
 pub(crate) static REFLECT_VALUE_ATTRIBUTE_NAME: &str = "reflect_value";
@@ -220,11 +219,7 @@ pub fn derive_type_path(input: TokenStream) -> TokenStream {
         Err(err) => return err.into_compile_error().into(),
     };
 
-    impls::impl_type_path(
-        derive_data.meta(),
-        &WhereClauseOptions::type_path_bounds(derive_data.meta()),
-    )
-    .into()
+    impls::impl_type_path(derive_data.meta()).into()
 }
 
 // From https://github.com/randomPoison/type-uuid
@@ -517,7 +512,7 @@ pub fn impl_type_path(input: TokenStream) -> TokenStream {
 
     let meta = ReflectMeta::new(type_path, ReflectTraits::default());
 
-    impls::impl_type_path(&meta, &WhereClauseOptions::type_path_bounds(&meta)).into()
+    impls::impl_type_path(&meta).into()
 }
 
 /// 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)]`.

crates/bevy_reflect/src/impls/smallvec.rs

@@ -148,7 +148,7 @@ where
     }
 }
 
-impl_type_path!(::smallvec::SmallVec<T: smallvec::Array + TypePath + Send + Sync>);
+impl_type_path!(::smallvec::SmallVec<T: smallvec::Array>);
 
 impl<T: smallvec::Array + TypePath + Send + Sync> FromReflect for SmallVec<T>
 where

crates/bevy_reflect/src/impls/std.rs

@@ -396,7 +396,7 @@ macro_rules! impl_reflect_for_veclike {
             }
         }
 
-        impl_type_path!($ty where T: FromReflect);
+        impl_type_path!($ty);
 
         impl<T: FromReflect + TypePath> GetTypeRegistration for $ty {
             fn get_type_registration() -> TypeRegistration {
@@ -655,20 +655,12 @@ impl_reflect_for_hashmap!(::std::collections::HashMap<K, V, S>);
 impl_type_path!(::std::collections::hash_map::RandomState);
 impl_type_path!(
     ::std::collections::HashMap<K, V, S>
-    where
-        K: FromReflect + Eq + Hash + ?Sized,
-        V: FromReflect + ?Sized,
-        S: BuildHasher + Send + Sync + 'static,
 );
 
 impl_reflect_for_hashmap!(bevy_utils::hashbrown::HashMap<K, V, S>);
 impl_type_path!(::bevy_utils::hashbrown::hash_map::DefaultHashBuilder);
 impl_type_path!(
     ::bevy_utils::hashbrown::HashMap<K, V, S>
-    where
-        K: FromReflect + Eq + Hash + ?Sized,
-        V: FromReflect + ?Sized,
-        S: BuildHasher + Send + Sync + 'static,
 );
 
 impl<T: Reflect + TypePath, const N: usize> Array for [T; N] {
@@ -798,7 +790,7 @@ impl<T: Reflect + TypePath, const N: usize> Typed for [T; N] {
     }
 }
 
-impl<T: Reflect + TypePath, const N: usize> TypePath for [T; N] {
+impl<T: TypePath, const N: usize> TypePath for [T; N] {
     fn type_path() -> &'static str {
         static CELL: GenericTypePathCell = GenericTypePathCell::new();
         CELL.get_or_insert::<Self, _>(|| format!("[{t}; {N}]", t = T::type_path()))
@@ -1073,7 +1065,21 @@ impl<T: FromReflect + TypePath> Typed for Option<T> {
     }
 }
 
-impl_type_path!(::core::option::Option<T: FromReflect + TypePath>);
+impl_type_path!(::core::option::Option<T>);
+
+impl<T: TypePath + ?Sized> TypePath for &'static T {
+    fn type_path() -> &'static str {
+        static CELL: GenericTypePathCell = GenericTypePathCell::new();
+        CELL.get_or_insert::<Self, _>(|| format!("&{}", T::type_path()))
+    }
+
+    fn short_type_path() -> &'static str {
+        static CELL: GenericTypePathCell = GenericTypePathCell::new();
+        CELL.get_or_insert::<Self, _>(|| format!("&{}", T::short_type_path()))
+    }
+
+    const TYPE_PATH_ID: TypePathId = TypePathId::from_base("&").with_generics(&[T::TYPE_PATH_ID]);
+}
 
 impl Reflect for Cow<'static, str> {
     fn get_represented_type_info(&self) -> Option<&'static TypeInfo> {
@@ -1262,21 +1268,6 @@ impl Typed for &'static Path {
     }
 }
 
-impl TypePath for &'static Path {
-    fn type_path() -> &'static str {
-        static CELL: GenericTypePathCell = GenericTypePathCell::new();
-        CELL.get_or_insert::<Self, _>(|| "&std::path::Path".to_owned())
-    }
-
-    fn short_type_path() -> &'static str {
-        static CELL: GenericTypePathCell = GenericTypePathCell::new();
-        CELL.get_or_insert::<Self, _>(|| "&Path".to_owned())
-    }
-
-    const TYPE_PATH_ID: TypePathId =
-        TypePathId::from_base("&").with_generics(&[<Path as TypePath>::TYPE_PATH_ID]);
-}
-
 impl GetTypeRegistration for &'static Path {
     fn get_type_registration() -> TypeRegistration {
         let mut registration = TypeRegistration::of::<Self>();
@@ -1378,10 +1369,7 @@ impl Typed for Cow<'static, Path> {
     }
 }
 
-trait Cowable: ToOwned {}
-impl Cowable for Path {}
-impl Cowable for str {}
-impl_type_path!(::alloc::borrow::Cow<'a: 'static, T: Cowable + ?Sized>);
+impl_type_path!(::alloc::borrow::Cow<'a: 'static, T: ToOwned + ?Sized>);
 
 impl FromReflect for Cow<'static, Path> {
     fn from_reflect(reflect: &dyn Reflect) -> Option<Self> {

crates/bevy_reflect/src/tuple.rs

@@ -654,7 +654,7 @@ impl TypePath for () {
 
 macro_rules! impl_type_path_tuple {
     ($($name:ident),+) => {
-        impl <$($name: Reflect + TypePath),*> TypePath for ($($name,)*) {
+        impl <$($name: TypePath),*> TypePath for ($($name,)*) {
             fn type_path() -> &'static str {
                 static CELL: GenericTypePathCell = GenericTypePathCell::new();
                 CELL.get_or_insert::<Self, _>(|| {

crates/bevy_reflect/src/type_path.rs

@@ -584,6 +584,7 @@ impl TypePathVtable {
         (self.module_path)()
     }
 
+    /// See [`TypePath::TYPE_PATH_ID`].
     pub fn type_path_id(&self) -> TypePathId {
         self.type_path_id
     }