Update macro doc link syntax

Author: MrGVSV

crates/bevy_reflect/bevy_reflect_derive/src/lib.rs

@@ -59,8 +59,8 @@ pub(crate) static REFLECT_VALUE_ATTRIBUTE_NAME: &str = "reflect_value";
 /// one for `ReflectFoo` and another for `ReflectBar`.
 /// This assumes these types are indeed in-scope wherever this macro is called.
 ///
-/// This is often used with traits that have been marked by the [`reflect_trait`] macro
-/// in order to register the type's implementation of that trait.
+/// This is often used with traits that have been marked by the [`#[reflect_trait]`](macro@reflect_trait)
+/// macro in order to register the type's implementation of that trait.
 ///
 /// ### Special Identifiers
 ///
@@ -146,7 +146,7 @@ pub fn derive_reflect(input: TokenStream) -> TokenStream {
 ///
 /// ## `#[reflect(ignore)]`
 ///
-/// The `#[reflect(ignore)]` attribute is shared with the [`Reflect` derive macro] and has much of the same
+/// The `#[reflect(ignore)]` attribute is shared with the [`#[derive(Reflect)]`](Reflect) macro and has much of the same
 /// functionality in that it marks a field to be ignored by the reflection API.
 ///
 /// The only major difference is that using it with this derive requires that the field implements [`Default`].
@@ -166,8 +166,6 @@ pub fn derive_reflect(input: TokenStream) -> TokenStream {
 /// or to remove the `Default` requirement on fields marked with `#[reflect(ignore)]`.
 /// Additionally, either form of this attribute can be used to fill in fields that are simply missing,
 /// such as when converting a partially-constructed dynamic type to a concrete one.
-///
-/// [`Reflect` derive macro]: Reflect
 #[proc_macro_derive(FromReflect, attributes(reflect))]
 pub fn derive_from_reflect(input: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(input as DeriveInput);
@@ -202,7 +200,7 @@ pub fn derive_type_uuid(input: TokenStream) -> TokenStream {
 /// For a trait named `MyTrait`, this will generate the struct `ReflectMyTrait`.
 /// The generated struct can be created using `FromType` with any type that implements the trait.
 /// The creation and registration of this generated struct as type data can be automatically handled
-/// by the [`Reflect` derive macro].
+/// by [`#[derive(Reflect)]`](Reflect).
 ///
 /// # Example
 ///
@@ -241,7 +239,6 @@ pub fn derive_type_uuid(input: TokenStream) -> TokenStream {
 /// ```
 ///
 /// [object-safe]: https://doc.rust-lang.org/reference/items/traits.html#object-safety
-/// [`Reflect` derive macro]: Reflect
 #[proc_macro_attribute]
 pub fn reflect_trait(args: TokenStream, input: TokenStream) -> TokenStream {
     trait_reflection::reflect_trait(&args, input)

crates/bevy_reflect/src/enums/enum_trait.rs

@@ -39,7 +39,7 @@ use std::slice::Iter;
 ///
 /// # Implementation
 ///
-/// > 💡 This trait can be automatically implemented using the [`Reflect` derive macro]
+/// > 💡 This trait can be automatically implemented using [`#[derive(Reflect)]`](derive@crate::Reflect)
 /// > on an enum definition.
 ///
 /// Despite the fact that enums can represent multiple states, traits only exist in one state
@@ -52,7 +52,7 @@ use std::slice::Iter;
 /// accessing fields!
 /// Again, this is to account for _all three_ variant types.
 ///
-/// We recommend using the built-in [`Reflect` derive macro] to automatically handle all the
+/// We recommend using the built-in [`#[derive(Reflect)]`](derive@crate::Reflect) macro to automatically handle all the
 /// implementation details for you.
 /// However, if you _must_ implement this trait manually, there are a few things to keep in mind...
 ///
@@ -87,7 +87,6 @@ use std::slice::Iter;
 /// [`None`]: core::option::Option<T>::None
 /// [`Some`]: core::option::Option<T>::Some
 /// [`Reflect`]: bevy_reflect_derive::Reflect
-/// [`Reflect` derive macro]: bevy_reflect_derive::Reflect
 pub trait Enum: Reflect {
     /// Returns a reference to the value of the field (in the current variant) with the given name.
     ///

crates/bevy_reflect/src/lib.rs

@@ -217,7 +217,7 @@
 //!
 //! With the derive macro, fields can be ignored or given default values for when a field is missing
 //! in the passed value.
-//! See the [derive macro documentation](bevy_reflect_derive::FromReflect) for details.
+//! See the [derive macro documentation](derive@crate::FromReflect) for details.
 //!
 //! All primitives and simple types implement `FromReflect` by relying on their [`Default`] implementation.
 //!
@@ -270,7 +270,7 @@
 //! These allow traits to be used directly on a `dyn Reflect` while utilizing the underlying type's implementation.
 //!
 //! For any [object-safe] trait, we can easily generate a corresponding `ReflectTrait` type for our trait
-//! using the [`reflect_trait`] macro.
+//! using the [`#[reflect_trait]`](reflect_trait) macro.
 //!
 //! ```
 //! # use bevy_reflect::{Reflect, reflect_trait, TypeRegistry};
@@ -380,9 +380,9 @@
 //! [Bevy]: https://bevyengine.org/
 //! [`bevy_reflect`]: crate
 //! [runtime cost]: https://doc.rust-lang.org/book/ch17-02-trait-objects.html#trait-objects-perform-dynamic-dispatch
-//! [derive macro]: bevy_reflect_derive::Reflect
+//! [derive macro]: derive@crate::Reflect
 //! [`'static` lifetime]: https://doc.rust-lang.org/rust-by-example/scope/lifetime/static_lifetime.html#trait-bound
-//! [derive macro documentation]: bevy_reflect_derive::Reflect
+//! [derive macro documentation]: derive@crate::Reflect
 //! [type data]: TypeData
 //! [`ReflectDefault`]: std_traits::ReflectDefault
 //! [object-safe]: https://doc.rust-lang.org/reference/items/traits.html#object-safety
@@ -399,7 +399,7 @@
 //! [`smallvec`]: https://docs.rs/smallvec/latest/smallvec/
 //! [orphan rule]: https://doc.rust-lang.org/book/ch10-02-traits.html#implementing-a-trait-on-a-type:~:text=But%20we%20can%E2%80%99t,implementation%20to%20use.
 //! [`bevy_reflect_derive/documentation`]: bevy_reflect_derive
-//! [derive `Reflect`]: bevy_reflect_derive::Reflect
+//! [derive `Reflect`]: derive@crate::Reflect
 
 mod array;
 mod fields;

crates/bevy_reflect/src/map.rs

@@ -16,7 +16,7 @@ use crate::{DynamicInfo, Reflect, ReflectMut, ReflectOwned, ReflectRef, TypeInfo
 /// # Hashing
 ///
 /// All keys are expected to return a valid hash value from [`Reflect::reflect_hash`].
-/// If using the [`Reflect` derive macro], this can be done by adding `#[reflect(Hash)]`
+/// If using the [`#[derive(Reflect)]`](derive@crate::Reflect) macro, this can be done by adding `#[reflect(Hash)]`
 /// to the entire struct or enum.
 /// This is true even for manual implementors who do not use the hashed value,
 /// as it is still relied on by [`DynamicMap`].
@@ -39,7 +39,6 @@ use crate::{DynamicInfo, Reflect, ReflectMut, ReflectOwned, ReflectRef, TypeInfo
 /// [map-like]: https://doc.rust-lang.org/book/ch08-03-hash-maps.html
 /// [reflection]: crate
 /// [`HashMap`]: bevy_utils::HashMap
-/// [`Reflect` derive macro]: bevy_reflect_derive::Reflect
 pub trait Map: Reflect {
     /// Returns a reference to the value associated with the given key.
     ///

crates/bevy_reflect/src/struct_trait.rs

@@ -15,7 +15,7 @@ use std::{
 /// This trait uses the [`Reflect`] trait to allow implementors to have their fields
 /// be dynamically addressed by both name and index.
 ///
-/// When using the [`Reflect` derive macro] on a standard struct,
+/// When using [`#[derive(Reflect)]`](derive@crate::Reflect) on a standard struct,
 /// this trait will be automatically implemented.
 /// This goes for [unit structs] as well.
 ///
@@ -40,7 +40,7 @@ use std::{
 ///
 /// [struct-like]: https://doc.rust-lang.org/book/ch05-01-defining-structs.html
 /// [reflection]: crate
-/// [`Reflect` derive macro]: bevy_reflect_derive::Reflect
+
 /// [unit structs]: https://doc.rust-lang.org/book/ch05-01-defining-structs.html#unit-like-structs-without-any-fields
 pub trait Struct: Reflect {
     /// Returns a reference to the value of the field named `name` as a `&dyn

crates/bevy_reflect/src/tuple_struct.rs

@@ -11,7 +11,7 @@ use std::slice::Iter;
 /// This trait uses the [`Reflect`] trait to allow implementors to have their fields
 /// be dynamically addressed by index.
 ///
-/// When using the [`Reflect` derive macro] on a tuple struct,
+/// When using [`#[derive(Reflect)]`](derive@crate::Reflect) on a tuple struct,
 /// this trait will be automatically implemented.
 ///
 /// # Example
@@ -32,7 +32,6 @@ use std::slice::Iter;
 ///
 /// [tuple struct-like]: https://doc.rust-lang.org/book/ch05-01-defining-structs.html#using-tuple-structs-without-named-fields-to-create-different-types
 /// [reflection]: crate
-/// [`Reflect` derive macro]: bevy_reflect_derive::Reflect
 pub trait TupleStruct: Reflect {
     /// Returns a reference to the value of the field with index `index` as a
     /// `&dyn Reflect`.

crates/bevy_reflect/src/type_info.rs

@@ -5,7 +5,7 @@ use std::any::{Any, TypeId};
 
 /// A static accessor to compile-time type information.
 ///
-/// This trait is automatically implemented by the [`Reflect` derive macro]
+/// This trait is automatically implemented by the [`#[derive(Reflect)]`](derive@crate::Reflect) macro
 /// and allows type information to be processed without an instance of that type.
 ///
 /// # Implementing
@@ -65,7 +65,6 @@ use std::any::{Any, TypeId};
 /// # }
 /// ```
 ///
-/// [`Reflect` derive macro]: bevy_reflect_derive::Reflect
 /// [utility]: crate::utility
 pub trait Typed: Reflect {
     /// Returns the compile-time [info] for the underlying type.

crates/bevy_reflect/src/type_registry.rs

@@ -11,13 +11,12 @@ use std::{any::TypeId, fmt::Debug, sync::Arc};
 /// This struct is used as the central store for type information.
 /// [Registering] a type will generate a new [`TypeRegistration`] entry in this store
 /// using a type's [`GetTypeRegistration`] implementation
-/// (which will is automatically implemented when using the [`Reflect` derive macro]).
+/// (which is automatically implemented when using [`#[derive(Reflect)]`](derive@crate::Reflect)).
 ///
 /// See the [crate-level documentation] for more information.
 ///
 /// [reflected]: crate
 /// [Registering]: TypeRegistry::register
-/// [`Reflect` derive macro]: bevy_reflect_derive::Reflect
 /// [crate-level documentation]: crate
 pub struct TypeRegistry {
     registrations: HashMap<TypeId, TypeRegistration>,
@@ -43,12 +42,11 @@ impl Debug for TypeRegistryArc {
 /// A trait which allows a type to generate its [`TypeRegistration`]
 /// for registration into the [`TypeRegistry`].
 ///
-/// This trait is automatically implemented for items using the [`Reflect` derive macro].
+/// This trait is automatically implemented for items using [`#[derive(Reflect)]`](derive@crate::Reflect).
 /// The macro also allows [`TypeData`] to be more easily registered.
 ///
 /// See the [crate-level documentation] for more information on type registration.
 ///
-/// [`Reflect` derive macro]: bevy_reflect_derive::Reflect
 /// [crate-level documentation]: crate
 pub trait GetTypeRegistration {
     fn get_type_registration() -> TypeRegistration;
@@ -279,7 +277,7 @@ impl TypeRegistryArc {
 /// Runtime storage for type metadata, registered into the [`TypeRegistry`].
 ///
 /// An instance of `TypeRegistration` can be created using the [`TypeRegistration::of`] method,
-/// but is more often automatically generated using the [`Reflect` derive macro] which itself generates
+/// but is more often automatically generated using [`#[derive(Reflect)]`](derive@crate::Reflect) which itself generates
 /// an implementation of the [`GetTypeRegistration`] trait.
 ///
 /// Along with the type's [`TypeInfo`] and [short name],
@@ -300,7 +298,6 @@ impl TypeRegistryArc {
 /// assert!(registration.data::<ReflectDefault>().is_some())
 /// ```
 ///
-/// [`Reflect` derive macro]: bevy_reflect_derive::Reflect
 /// [short name]: bevy_utils::get_short_name
 /// [crate-level documentation]: crate
 pub struct TypeRegistration {
@@ -403,13 +400,12 @@ impl Clone for TypeRegistration {
 ///
 /// Type data can be registered to the [`TypeRegistry`] and stored on a type's [`TypeRegistration`].
 ///
-/// While type data is often generated using the [`#[reflect_trait]`][0] macro,
+/// While type data is often generated using the [`#[reflect_trait]`](crate::reflect_trait) macro,
 /// almost any type that implements [`Clone`] can be considered "type data".
 /// This is because it has a blanket implementation over all `T` where `T: Clone + Send + Sync + 'static`.
 ///
 /// See the [crate-level documentation] for more information on type data and type registration.
 ///
-/// [0]: crate::reflect_trait
 /// [crate-level documentation]: crate
 pub trait TypeData: Downcast + Send + Sync {
     fn clone_type_data(&self) -> Box<dyn TypeData>;