doc cleanup

Author: Victoronz

crates/bevy_ecs/src/entity/entity_set.rs

@@ -58,7 +58,7 @@ pub trait ContainsEntity {
 /// To obtain hash values forming the same total order as [`Entity`], any [`Hasher`] used must be
 /// deterministic and concerning [`Entity`], collisionless.
 /// Standard library hash collections handle collisions with an [`Eq`] fallback, but do not account for
-/// determinism when [`BuildHasher`] is unspecified,.
+/// determinism when [`BuildHasher`] is unspecified.
 ///
 /// [`Hash`]: core::hash::Hash
 /// [`Hasher`]: core::hash::Hasher
@@ -149,12 +149,12 @@ unsafe impl<T: EntityEquivalent> EntityEquivalent for Arc<T> {}
 /// As a consequence, [`into_iter()`] on `EntitySet` will always produce another `EntitySet`.
 ///
 /// Implementing this trait allows for unique query iteration over a list of entities.
-/// See [`iter_many_unique`] and [`iter_many_unique_mut`]
+/// See [`iter_many_unique`] and [`iter_many_unique_mut`].
 ///
 /// Note that there is no guarantee of the [`IntoIterator`] impl being deterministic,
 /// it might return different iterators when called multiple times.
 /// Neither is there a guarantee that the comparison trait impls of `EntitySet` match that
-/// of the respective [`EntitySetIterator`] (or of a [`Vec`] collected from its elements)
+/// of the respective [`EntitySetIterator`] (or of a [`Vec`] collected from its elements).
 ///
 /// [`Self::IntoIter`]: IntoIterator::IntoIter
 /// [`into_iter()`]: IntoIterator::into_iter

crates/bevy_ecs/src/entity/hash_map.rs

@@ -36,7 +36,7 @@ impl<V> EntityHashMap<V> {
     ///
     /// Equivalent to [`HashMap::with_capacity_and_hasher(n, EntityHash)`].
     ///
-    /// [`HashMap:with_capacity_and_hasher(n, EntityHash)`]: HashMap::with_capacity_and_hasher
+    /// [`HashMap::with_capacity_and_hasher(n, EntityHash)`]: HashMap::with_capacity_and_hasher
     #[inline]
     pub fn with_capacity(n: usize) -> Self {
         Self(HashMap::with_capacity_and_hasher(n, EntityHash))

crates/bevy_ecs/src/entity/index_map.rs

@@ -18,7 +18,11 @@ use core::{
 #[cfg(feature = "bevy_reflect")]
 use bevy_reflect::Reflect;
 pub use indexmap::map::Entry;
-use indexmap::map::{self, IndexMap, IntoValues, ValuesMut};
+use indexmap::{
+    self,
+    map::{self, IntoValues, ValuesMut},
+    IndexMap,
+};
 
 use super::{Entity, EntityEquivalent, EntityHash, EntitySetIterator};
 
@@ -35,7 +39,7 @@ impl<V> EntityIndexMap<V> {
     ///
     /// Equivalent to [`IndexMap::with_hasher(EntityHash)`].
     ///
-    /// [`IndexMap::with_hasher(EntityHash)`]: IndexMap::with_hasher
+    /// [`IndexMap::with_hasher(EntityHash)`]: indexmap::IndexMap::with_hasher
     #[inline]
     pub const fn new() -> Self {
         Self(IndexMap::with_hasher(EntityHash))
@@ -45,7 +49,7 @@ impl<V> EntityIndexMap<V> {
     ///
     /// Equivalent to [`IndexMap::with_capacity_and_hasher(n, EntityHash)`].
     ///
-    /// [`IndexMap:with_capacity_and_hasher(n, EntityHash)`]: IndexMap::with_capacity_and_hasher
+    /// [`IndexMap::with_capacity_and_hasher(n, EntityHash)`]: indexmap::IndexMap::with_capacity_and_hasher
     #[inline]
     pub fn with_capacity(n: usize) -> Self {
         Self(IndexMap::with_capacity_and_hasher(n, EntityHash))
@@ -1224,15 +1228,15 @@ impl<'a, V> Drain<'a, V> {
         Drain::<'_, _, S>(drain, PhantomData)
     }
 
-    /// Returns the inner [`Drain`](map::Drain).
+    /// Returns the inner [`Drain`](indexmap::map::Drain).
     #[inline]
     pub fn into_inner(self) -> map::Drain<'a, Entity, V> {
         self.0
     }
 
     /// Returns a slice of the remaining entries in the iterator.
     ///
-    /// Equivalent to [`map::Drain::as_slice`].
+    /// Equivalent to [`map::Drain::as_slice`](`indexmap::map::Drain::as_slice`).
     #[inline]
     pub fn as_slice(&self) -> &Slice<V> {
         // SAFETY: The source IndexMap uses EntityHash.

crates/bevy_ecs/src/entity/index_set.rs

@@ -16,7 +16,7 @@ use core::{
     ptr,
 };
 
-use indexmap::set::{self, IndexSet};
+use indexmap::{self, set, IndexSet};
 
 use super::{Entity, EntityHash, EntitySetIterator};
 

crates/bevy_ecs/src/entity/unique_slice.rs

@@ -369,7 +369,8 @@ impl<T: EntityEquivalent> UniqueEntityEquivalentSlice<T> {
         }
     }
 
-    ///
+    /// Returns an iterator over `chunk_size` elements of the slice at a time, starting at the
+    /// beginning of the slice.
     ///
     /// Equivalent to [`[T]::chunks_exact`].
     ///

crates/bevy_ecs/src/entity/unique_vec.rs

@@ -91,7 +91,7 @@ impl<T: EntityEquivalent> UniqueEntityEquivalentVec<T> {
         Self(vec)
     }
 
-    /// Constructs a `UniqueEntityEquivalentVec` from a [`&Vec<T>`] unsafely.
+    /// Constructs a `UniqueEntityEquivalentVec` from a [`&Vec<T>`](Vec) unsafely.
     ///
     /// # Safety
     ///
@@ -102,7 +102,7 @@ impl<T: EntityEquivalent> UniqueEntityEquivalentVec<T> {
         unsafe { &*ptr::from_ref(vec).cast() }
     }
 
-    /// Constructs a `UniqueEntityEquivalentVec` from a [`&mut Vec<T>`] unsafely.
+    /// Constructs a `UniqueEntityEquivalentVec` from a [`&mut Vec<T>`](Vec) unsafely.
     ///
     /// # Safety
     ///