fix a bunch of docs links

Author: makspll

crates/bevy_mod_scripting_bindings/src/allocator.rs

@@ -195,13 +195,13 @@ pub struct ReflectAllocator {
 
 #[profiling::all_functions]
 impl ReflectAllocator {
-    /// Allocates a new [`Reflect`] value and returns an [`AllocationId`] which can be used to access it later.
+    /// Allocates a new `Reflect` value and returns an [`ReflectAllocationId`] which can be used to access it later.
     /// Use [`Self::allocate_boxed`] if you already have an allocated boxed value.
     pub fn allocate<T: PartialReflect>(&mut self, value: T) -> ReflectAllocationId {
         self.allocate_boxed(Box::new(value))
     }
 
-    /// Allocates a new boxed [`PartialReflect`] value and returns an [`AllocationId`] which can be used to access it later.
+    /// Allocates a new boxed `PartialReflect` value and returns an [`ReflectAllocationId`] which can be used to access it later.
     pub fn allocate_boxed(&mut self, value: Box<dyn PartialReflect>) -> ReflectAllocationId {
         static COUNTER: AtomicU64 = AtomicU64::new(0);
 
@@ -236,7 +236,7 @@ impl ReflectAllocator {
         self.allocations.get(id)
     }
 
-    /// Deallocates the [`PartialReflect`] value with the given [`AllocationId`]
+    /// Deallocates the `PartialReflect` value with the given [`ReflectAllocationId`]
     pub fn deallocate(&mut self, id: &ReflectAllocationId) {
         self.allocations.remove(id);
     }

crates/bevy_mod_scripting_bindings/src/docgen/typed_through.rs

@@ -1,5 +1,5 @@
-//! Defines a set of traits which destruture [`bevy::reflect::TypeInfo`] and implement a light weight wrapper around it, to allow types
-//! which normally can't implement [`bevy::reflect::Typed`] to be used in a reflection context.
+//! Defines a set of traits which destruture [`bevy_reflect::TypeInfo`] and implement a light weight wrapper around it, to allow types
+//! which normally can't implement [`bevy_reflect::Typed`] to be used in a reflection context.
 
 use std::{ffi::OsString, path::PathBuf};
 

crates/bevy_mod_scripting_bindings/src/function/from.rs

@@ -229,7 +229,7 @@ impl<T: FromReflect> FromScript for Val<T> {
 /// Before downcasting the reference, it will claim write access to the object to ensure that the reference is valid.
 ///
 /// However, the access is NOT released when the `Mut` is dropped. This is not unsafe but can lead to deadlocks if not released later.
-/// The [`ScriptFunction`] calling mechanism will take care of releasing all accesses claimed during the function call.
+/// The script function calling mechanism will take care of releasing all accesses claimed during the function call.
 pub struct Ref<'w, T>(pub &'w T);
 
 impl<T> Deref for Ref<'_, T> {

crates/bevy_mod_scripting_bindings/src/function/into_ref.rs

@@ -10,15 +10,15 @@ use crate::{
     reflection_extensions::PartialReflectExt,
 };
 
-/// Converts a value represented by a reference into a [`crate::function::ScriptValue`].
+/// Converts a value represented by a reference into a [`crate::ScriptValue`].
 /// Instead of a direct conversion, the trait tries to peek into the value behind the reference and find out the most suitable representation.
 ///
 /// Type Erased version of [`super::from::FromScript`].
 ///
 /// - Primitives are converted to simple values
 /// - Container types are converted to references (so the references persist after accesses inside them)
 pub trait IntoScriptRef {
-    /// Converts a value represented by a reference into a [`crate::function::ScriptValue`].
+    /// Converts a value represented by a reference into a [`crate::ScriptValue`].
     fn into_script_ref(
         self_: ReflectReference,
         world: WorldGuard,

crates/bevy_mod_scripting_bindings/src/function/script_function.rs

@@ -264,7 +264,7 @@ where
 #[debug_with_type_info(bms_display_path = "bevy_mod_scripting_display")]
 pub struct DummyScriptFunctionRegistry(pub ScriptFunctionRegistryArc);
 
-/// Equivalent to [`AppFunctionRegistry`] but stores functions with a more convenient signature for scripting to avoid boxing every argument.
+/// Equivalent to [`AppScriptFunctionRegistry`] but stores functions with a more convenient signature for scripting to avoid boxing every argument.
 #[derive(Clone, Default, Resource, DebugWithTypeInfo)]
 #[debug_with_type_info(bms_display_path = "bevy_mod_scripting_display")]
 pub struct AppScriptFunctionRegistry(pub ScriptFunctionRegistryArc);

crates/bevy_mod_scripting_bindings/src/reference.rs

@@ -354,11 +354,11 @@ impl ReflectReference {
         })?
     }
 
-    /// Attempts to create a [`Box<dyn PartialReflect>`] from the reference. This is possible using a few strategies:
-    /// - If the reference is to a world, a [`WorldCallbackAccess`] is created and boxed
+    /// Attempts to create a `Box<dyn PartialReflect>` from the reference. This is possible using a few strategies:
+    /// - If the reference is to a world, a [`crate::world::WorldCallbackAccess`] is created and boxed
     /// - If the reference is to an allocation with no reflection path and references to it, the value is taken as is.
-    /// - If the reference has a [`bevy::reflect::ReflectFromReflect`] type data associated with it, the value is cloned using that impl.
-    /// - If all above fails, [`bevy::reflect::PartialReflect::clone_value`] is used to clone the value.
+    /// - If the reference has a [`bevy_reflect::ReflectFromReflect`] type data associated with it, the value is cloned using that impl.
+    /// - If all above fails, [`bevy_reflect::PartialReflect::clone_value`] is used to clone the value.
     ///
     pub fn to_owned_value(
         &self,
@@ -466,7 +466,7 @@ impl ReflectReference {
     /// - The caller must ensure the cell has permission to access the underlying value
     /// - The caller must ensure no aliasing references to the same value exist at all at the same time
     ///
-    /// To do this safely you need to use [`WorldAccessGuard::claim_read_access`] or [`WorldAccessGuard::claim_global_access`] to ensure nobody else is currently accessing the value.
+    /// To do this safely you need to use [`crate::world::WorldAccessGuard::claim_read_access`] or [`crate::world::WorldAccessGuard::claim_global_access`] to ensure nobody else is currently accessing the value.
     pub unsafe fn reflect_unsafe<'w>(
         &self,
         world: WorldGuard<'w>,
@@ -527,7 +527,7 @@ impl ReflectReference {
     /// - The caller must ensure the cell has permission to access the underlying value
     /// - The caller must ensure no other references to the same value exist at all at the same time (even if you have the correct access)
     ///
-    /// To do this safely you need to use [`WorldAccessGuard::claim_write_access`] or [`WorldAccessGuard::claim_global_access`] to ensure nobody else is currently accessing the value.
+    /// To do this safely you need to use [`crate::world::WorldAccessGuard::claim_write_access`] or [`crate::world::WorldAccessGuard::claim_global_access`] to ensure nobody else is currently accessing the value.
     pub unsafe fn reflect_mut_unsafe<'w>(
         &self,
         world: WorldGuard<'w>,

crates/bevy_mod_scripting_bindings/src/world.rs

@@ -69,7 +69,7 @@ pub type WorldGuard<'w> = WorldAccessGuard<'w>;
 /// Similar to [`WorldGuard`], but without the arc, use for when you don't need the outer Arc.
 pub type WorldGuardRef<'w> = &'w WorldAccessGuard<'w>;
 
-/// Provides safe access to the world via [`WorldAccess`] permissions, which enforce aliasing rules at runtime in multi-thread environments
+/// Provides safe access to the world via [`AnyAccessMap`] permissions, which enforce aliasing rules at runtime in multi-thread environments
 #[derive(Clone, Debug)]
 pub struct WorldAccessGuard<'w> {
     /// The guard this guard pointer represents

crates/bevy_mod_scripting_core/src/commands.rs

@@ -108,7 +108,7 @@ impl<P: IntoScriptPluginParams> RunScriptCallback<P> {
         result
     }
 
-    /// Equivalent to [`Self::run`], but usable in the case where you already have a [`HandlerContext`].
+    /// Equivalent to [`Self::run`], but usable in the case where you already have [`ScriptContext`] and [`ScriptCallbacks`] resources available.
     pub fn run_with_contexts(
         self,
         guard: WorldGuard,

crates/bevy_mod_scripting_core/src/lib.rs

@@ -64,7 +64,7 @@ pub enum ScriptingSystemSet {
 ///
 /// When implementing a new scripting plugin, also ensure the following implementations exist:
 /// - [`Plugin`] for the plugin, both [`Plugin::build`] and [`Plugin::finish`] methods need to be dispatched to the underlying [`ScriptingPlugin`] struct
-/// - [`AsMut<ScriptingPlugin<Self>`] for the plugin struct
+/// - [`AsMut<ScriptingPlugin<Self>>`] for the plugin struct
 pub trait IntoScriptPluginParams: 'static + GetPluginThreadConfig<Self> {
     /// The language of the scripts
     const LANGUAGE: Language;

crates/bevy_mod_scripting_core/src/pipeline/mod.rs

@@ -48,17 +48,17 @@ pub enum PipelineSet {
 
 /// A pipeline plugin which enables the loading and unloading of scripts in a highly modular way
 pub struct ScriptLoadingPipeline<P: IntoScriptPluginParams> {
-    /// by default the plugin will listen to [`ScriptComponent`] attachments/detachments and synchronize scripts accordingly,
+    /// by default the plugin will listen to [`crate::ScriptComponent`] attachments/detachments and synchronize scripts accordingly,
     /// you can opt out of this behavior by disabling this flag.
     pub script_component_triggers: bool,
-    /// by default the plugin will listen to [`AssetEvent<ScriptAsset>`] events, and trigger the pipeline on asset modifications.
+    /// by default the plugin will listen to [`bevy_asset::AssetEvent<ScriptAsset>`] events, and trigger the pipeline on asset modifications.
     pub hot_loading_asset_triggers: bool,
 
-    /// If true the [`OnScriptLoaded`] callback will be triggered when loading scripts
+    /// If true the [`crate::event::OnScriptLoaded`] callback will be triggered when loading scripts
     pub on_script_loaded_callback: bool,
-    /// If true the [`OnScriptReloaded`] callback will be triggered when loading scripts
+    /// If true the [`crate::event::OnScriptReloaded`] callback will be triggered when loading scripts
     pub on_script_reloaded_callback: bool,
-    /// If true the [`OnScriptUnloaded`] callback will be triggered when loading scripts
+    /// If true the [`crate::event::OnScriptUnloaded`] callback will be triggered when loading scripts
     pub on_script_unloaded_callback: bool,
     _ph: PhantomData<fn(P)>,