turn various entity set functions const

Author: Victoronz

crates/bevy_ecs/src/entity/entity_set.rs

@@ -373,7 +373,7 @@ pub struct UniqueEntityIter<I: Iterator<Item: EntityEquivalent>> {
 impl<I: EntitySetIterator> UniqueEntityIter<I> {
     /// Constructs a `UniqueEntityIter` from an [`EntitySetIterator`].
     #[inline]
-    pub fn from_entity_set_iter<S>(iter: I) -> Self {
+    pub const fn from_entity_set_iter<S>(iter: I) -> Self {
         // SAFETY: iter implements `EntitySetIterator`.
         unsafe { Self::from_iter_unchecked(iter) }
     }
@@ -386,7 +386,7 @@ impl<I: Iterator<Item: EntityEquivalent>> UniqueEntityIter<I> {
     /// `iter` must only yield unique elements.
     /// As in, the resulting iterator must adhere to the safety contract of [`EntitySetIterator`].
     #[inline]
-    pub unsafe fn from_iter_unchecked(iter: I) -> Self {
+    pub const unsafe fn from_iter_unchecked(iter: I) -> Self {
         Self { iter }
     }
 
@@ -396,7 +396,7 @@ impl<I: Iterator<Item: EntityEquivalent>> UniqueEntityIter<I> {
     /// `iter` must only yield unique elements.
     /// As in, the resulting iterator must adhere to the safety contract of [`EntitySetIterator`].
     #[inline]
-    pub unsafe fn from_iter_ref_unchecked(iter: &I) -> &Self {
+    pub const unsafe fn from_iter_ref_unchecked(iter: &I) -> &Self {
         // SAFETY: UniqueEntityIter is a transparent wrapper around I.
         unsafe { &*ptr::from_ref(iter).cast() }
     }
@@ -407,7 +407,7 @@ impl<I: Iterator<Item: EntityEquivalent>> UniqueEntityIter<I> {
     /// `iter` must only yield unique elements.
     /// As in, the resulting iterator must adhere to the safety contract of [`EntitySetIterator`].
     #[inline]
-    pub unsafe fn from_iter_mut_unchecked(iter: &mut I) -> &mut Self {
+    pub const unsafe fn from_iter_mut_unchecked(iter: &mut I) -> &mut Self {
         // SAFETY: UniqueEntityIter is a transparent wrapper around I.
         unsafe { &mut *ptr::from_mut(iter).cast() }
     }
@@ -420,7 +420,7 @@ impl<I: Iterator<Item: EntityEquivalent>> UniqueEntityIter<I> {
 
     /// Returns a reference to the inner `I`.
     #[inline]
-    pub fn as_inner(&self) -> &I {
+    pub const fn as_inner(&self) -> &I {
         &self.iter
     }
 
@@ -431,7 +431,7 @@ impl<I: Iterator<Item: EntityEquivalent>> UniqueEntityIter<I> {
     /// `self` must always contain an iterator that yields unique elements,
     /// even while this reference is live.
     #[inline]
-    pub unsafe fn as_mut_inner(&mut self) -> &mut I {
+    pub const unsafe fn as_mut_inner(&mut self) -> &mut I {
         &mut self.iter
     }
 }

crates/bevy_ecs/src/entity/hash_map.rs

@@ -44,7 +44,7 @@ impl<V> EntityHashMap<V> {
 
     /// Constructs an `EntityHashMap` from an [`HashMap`].
     #[inline]
-    pub fn from_index_map(set: HashMap<Entity, V, EntityHash>) -> Self {
+    pub const fn from_index_map(set: HashMap<Entity, V, EntityHash>) -> Self {
         Self(set)
     }
 
@@ -193,13 +193,15 @@ impl<'a, V> Keys<'a, V> {
     /// `keys` must either be empty, or have been obtained from a
     /// [`hash_map::HashMap`] using the `S` hasher.
     #[inline]
-    pub unsafe fn from_keys_unchecked<S>(keys: hash_map::Keys<'a, Entity, V>) -> Keys<'a, V, S> {
+    pub const unsafe fn from_keys_unchecked<S>(
+        keys: hash_map::Keys<'a, Entity, V>,
+    ) -> Keys<'a, V, S> {
         Keys::<'_, _, S>(keys, PhantomData)
     }
 
     /// Returns the inner [`Keys`](hash_map::Keys).
     #[inline]
-    pub fn into_inner(self) -> hash_map::Keys<'a, Entity, V> {
+    pub const fn into_inner(self) -> hash_map::Keys<'a, Entity, V> {
         self.0
     }
 }
@@ -269,7 +271,7 @@ impl<V> IntoKeys<V> {
     /// `into_keys` must either be empty, or have been obtained from a
     /// [`hash_map::HashMap`] using the `S` hasher.
     #[inline]
-    pub unsafe fn from_into_keys_unchecked<S>(
+    pub const unsafe fn from_into_keys_unchecked<S>(
         into_keys: hash_map::IntoKeys<Entity, V>,
     ) -> IntoKeys<V, S> {
         IntoKeys::<_, S>(into_keys, PhantomData)

crates/bevy_ecs/src/entity/hash_set.rs

@@ -59,7 +59,7 @@ impl EntityHashSet {
 
     /// Constructs an `EntityHashSet` from an [`HashSet`].
     #[inline]
-    pub fn from_hash_set(set: HashSet<Entity, EntityHash>) -> Self {
+    pub const fn from_hash_set(set: HashSet<Entity, EntityHash>) -> Self {
         Self(set)
     }
 
@@ -255,13 +255,13 @@ impl<'a> Iter<'a> {
     /// `iter` must either be empty, or have been obtained from a
     /// [`hash_set::HashSet`] using the `S` hasher.
     #[inline]
-    pub unsafe fn from_iter_unchecked<S>(iter: hash_set::Iter<'a, Entity>) -> Iter<'a, S> {
+    pub const unsafe fn from_iter_unchecked<S>(iter: hash_set::Iter<'a, Entity>) -> Iter<'a, S> {
         Iter::<'_, S>(iter, PhantomData)
     }
 
     /// Returns the inner [`Iter`](hash_set::Iter).
     #[inline]
-    pub fn into_inner(self) -> hash_set::Iter<'a, Entity> {
+    pub const fn into_inner(self) -> hash_set::Iter<'a, Entity> {
         self.0
     }
 }
@@ -328,7 +328,7 @@ impl IntoIter {
     /// `into_iter` must either be empty, or have been obtained from a
     /// [`hash_set::HashSet`] using the `S` hasher.
     #[inline]
-    pub unsafe fn from_into_iter_unchecked<S>(
+    pub const unsafe fn from_into_iter_unchecked<S>(
         into_iter: hash_set::IntoIter<Entity>,
     ) -> IntoIter<S> {
         IntoIter::<S>(into_iter, PhantomData)
@@ -398,7 +398,9 @@ impl<'a> Drain<'a> {
     /// `drain` must either be empty, or have been obtained from a
     /// [`hash_set::HashSet`] using the `S` hasher.
     #[inline]
-    pub unsafe fn from_drain_unchecked<S>(drain: hash_set::Drain<'a, Entity>) -> Drain<'a, S> {
+    pub const unsafe fn from_drain_unchecked<S>(
+        drain: hash_set::Drain<'a, Entity>,
+    ) -> Drain<'a, S> {
         Drain::<'_, S>(drain, PhantomData)
     }
 
@@ -461,7 +463,7 @@ impl<'a, F: FnMut(&Entity) -> bool> ExtractIf<'a, F> {
     /// `extract_if` must either be empty, or have been obtained from a
     /// [`hash_set::HashSet`] using the `S` hasher.
     #[inline]
-    pub unsafe fn from_extract_if_unchecked<S>(
+    pub const unsafe fn from_extract_if_unchecked<S>(
         extract_if: hash_set::ExtractIf<'a, Entity, F>,
     ) -> ExtractIf<'a, F, S> {
         ExtractIf::<'_, _, S>(extract_if, PhantomData)

crates/bevy_ecs/src/entity/index_map.rs

@@ -53,7 +53,7 @@ impl<V> EntityIndexMap<V> {
 
     /// Constructs an `EntityIndexMap` from an [`IndexMap`].
     #[inline]
-    pub fn from_index_map(set: IndexMap<Entity, V, EntityHash>) -> Self {
+    pub const fn from_index_map(set: IndexMap<Entity, V, EntityHash>) -> Self {
         Self(set)
     }
 
@@ -482,7 +482,7 @@ impl<V> Slice<V> {
         reason = "We wish to access the Box API of the inner type, without consuming it."
     )]
     #[inline]
-    pub fn as_boxed_inner(self: &Box<Self>) -> &Box<map::Slice<Entity, V>> {
+    pub const fn as_boxed_inner(self: &Box<Self>) -> &Box<map::Slice<Entity, V>> {
         // SAFETY: Slice is a transparent wrapper around indexmap::map::Slice.
         unsafe { &*(ptr::from_ref(self).cast::<Box<map::Slice<Entity, V>>>()) }
     }
@@ -943,13 +943,13 @@ impl<'a, V> Iter<'a, V> {
     /// `iter` must either be empty, or have been obtained from a
     /// [`IndexMap`] using the `S` hasher.
     #[inline]
-    pub unsafe fn from_iter_unchecked<S>(iter: map::Iter<'a, Entity, V>) -> Iter<'a, V, S> {
+    pub const unsafe fn from_iter_unchecked<S>(iter: map::Iter<'a, Entity, V>) -> Iter<'a, V, S> {
         Iter::<'_, _, S>(iter, PhantomData)
     }
 
     /// Returns the inner [`Iter`](map::Iter).
     #[inline]
-    pub fn into_inner(self) -> map::Iter<'a, Entity, V> {
+    pub const fn into_inner(self) -> map::Iter<'a, Entity, V> {
         self.0
     }
 
@@ -1028,15 +1028,15 @@ impl<'a, V> IterMut<'a, V> {
     /// `iter_mut` must either be empty, or have been obtained from a
     /// [`IndexMap`] using the `S` hasher.
     #[inline]
-    pub unsafe fn from_iter_mut_unchecked<S>(
+    pub const unsafe fn from_iter_mut_unchecked<S>(
         iter_mut: map::IterMut<'a, Entity, V>,
     ) -> IterMut<'a, V, S> {
         IterMut::<'_, _, S>(iter_mut, PhantomData)
     }
 
     /// Returns the inner [`IterMut`](map::IterMut).
     #[inline]
-    pub fn into_inner(self) -> map::IterMut<'a, Entity, V> {
+    pub const fn into_inner(self) -> map::IterMut<'a, Entity, V> {
         self.0
     }
 
@@ -1119,7 +1119,7 @@ impl<V> IntoIter<V> {
     /// `into_iter` must either be empty, or have been obtained from a
     /// [`IndexMap`] using the `S` hasher.
     #[inline]
-    pub unsafe fn from_into_iter_unchecked<S>(
+    pub const unsafe fn from_into_iter_unchecked<S>(
         into_iter: map::IntoIter<Entity, V>,
     ) -> IntoIter<V, S> {
         IntoIter::<_, S>(into_iter, PhantomData)
@@ -1218,7 +1218,9 @@ impl<'a, V> Drain<'a, V> {
     /// `drain` must either be empty, or have been obtained from a
     /// [`IndexMap`] using the `S` hasher.
     #[inline]
-    pub unsafe fn from_drain_unchecked<S>(drain: map::Drain<'a, Entity, V>) -> Drain<'a, V, S> {
+    pub const unsafe fn from_drain_unchecked<S>(
+        drain: map::Drain<'a, Entity, V>,
+    ) -> Drain<'a, V, S> {
         Drain::<'_, _, S>(drain, PhantomData)
     }
 
@@ -1290,13 +1292,13 @@ impl<'a, V> Keys<'a, V> {
     /// `keys` must either be empty, or have been obtained from a
     /// [`IndexMap`] using the `S` hasher.
     #[inline]
-    pub unsafe fn from_keys_unchecked<S>(keys: map::Keys<'a, Entity, V>) -> Keys<'a, V, S> {
+    pub const unsafe fn from_keys_unchecked<S>(keys: map::Keys<'a, Entity, V>) -> Keys<'a, V, S> {
         Keys::<'_, _, S>(keys, PhantomData)
     }
 
     /// Returns the inner [`Keys`](map::Keys).
     #[inline]
-    pub fn into_inner(self) -> map::Keys<'a, Entity, V> {
+    pub const fn into_inner(self) -> map::Keys<'a, Entity, V> {
         self.0
     }
 }
@@ -1378,7 +1380,7 @@ impl<V> IntoKeys<V> {
     /// `into_keys` must either be empty, or have been obtained from a
     /// [`IndexMap`] using the `S` hasher.
     #[inline]
-    pub unsafe fn from_into_keys_unchecked<S>(
+    pub const unsafe fn from_into_keys_unchecked<S>(
         into_keys: map::IntoKeys<Entity, V>,
     ) -> IntoKeys<V, S> {
         IntoKeys::<_, S>(into_keys, PhantomData)

crates/bevy_ecs/src/entity/index_set.rs

@@ -50,7 +50,7 @@ impl EntityIndexSet {
 
     /// Constructs an `EntityIndexSet` from an [`IndexSet`].
     #[inline]
-    pub fn from_index_set(set: IndexSet<Entity, EntityHash>) -> Self {
+    pub const fn from_index_set(set: IndexSet<Entity, EntityHash>) -> Self {
         Self(set)
     }
 
@@ -362,7 +362,7 @@ impl Slice {
         reason = "We wish to access the Box API of the inner type, without consuming it."
     )]
     #[inline]
-    pub fn as_boxed_inner(self: &Box<Self>) -> &Box<set::Slice<Entity>> {
+    pub const fn as_boxed_inner(self: &Box<Self>) -> &Box<set::Slice<Entity>> {
         // SAFETY: Slice is a transparent wrapper around indexmap::set::Slice.
         unsafe { &*(ptr::from_ref(self).cast::<Box<set::Slice<Entity>>>()) }
     }
@@ -624,13 +624,13 @@ impl<'a> Iter<'a> {
     /// `iter` must either be empty, or have been obtained from a
     /// [`IndexSet`] using the `S` hasher.
     #[inline]
-    pub unsafe fn from_iter_unchecked<S>(iter: set::Iter<'a, Entity>) -> Iter<'a, S> {
+    pub const unsafe fn from_iter_unchecked<S>(iter: set::Iter<'a, Entity>) -> Iter<'a, S> {
         Iter::<'_, S>(iter, PhantomData)
     }
 
     /// Returns the inner [`Iter`](set::Iter).
     #[inline]
-    pub fn into_inner(self) -> set::Iter<'a, Entity> {
+    pub const fn into_inner(self) -> set::Iter<'a, Entity> {
         self.0
     }
 
@@ -713,7 +713,9 @@ impl IntoIter {
     /// `into_iter` must either be empty, or have been obtained from a
     /// [`IndexSet`] using the `S` hasher.
     #[inline]
-    pub unsafe fn from_into_iter_unchecked<S>(into_iter: set::IntoIter<Entity>) -> IntoIter<S> {
+    pub const unsafe fn from_into_iter_unchecked<S>(
+        into_iter: set::IntoIter<Entity>,
+    ) -> IntoIter<S> {
         IntoIter::<S>(into_iter, PhantomData)
     }
 
@@ -805,7 +807,7 @@ impl<'a> Drain<'a> {
     /// `drain` must either be empty, or have been obtained from a
     /// [`IndexSet`] using the `S` hasher.
     #[inline]
-    pub unsafe fn from_drain_unchecked<S>(drain: set::Drain<'a, Entity>) -> Drain<'a, S> {
+    pub const unsafe fn from_drain_unchecked<S>(drain: set::Drain<'a, Entity>) -> Drain<'a, S> {
         Drain::<'_, S>(drain, PhantomData)
     }
 

crates/bevy_ecs/src/entity/unique_array.rs

@@ -124,7 +124,7 @@ impl<T: EntityEquivalent, const N: usize> UniqueEntityEquivalentArray<T, N> {
 
     /// Returns a reference to the inner array.
     #[inline]
-    pub fn as_inner(&self) -> &[T; N] {
+    pub const fn as_inner(&self) -> &[T; N] {
         &self.0
     }
 
@@ -138,7 +138,7 @@ impl<T: EntityEquivalent, const N: usize> UniqueEntityEquivalentArray<T, N> {
     /// Returns a mutable slice containing the entire array. Equivalent to
     /// `&mut s[..]`.
     #[inline]
-    pub fn as_mut_slice(&mut self) -> &mut UniqueEntityEquivalentSlice<T> {
+    pub const fn as_mut_slice(&mut self) -> &mut UniqueEntityEquivalentSlice<T> {
         // SAFETY: All elements in the original array are unique.
         unsafe { UniqueEntityEquivalentSlice::from_slice_unchecked_mut(self.0.as_mut_slice()) }
     }
@@ -148,7 +148,7 @@ impl<T: EntityEquivalent, const N: usize> UniqueEntityEquivalentArray<T, N> {
     ///
     /// Equivalent to [`[T; N]::as_ref`](array::each_ref).
     #[inline]
-    pub fn each_ref(&self) -> UniqueEntityEquivalentArray<&T, N> {
+    pub const fn each_ref(&self) -> UniqueEntityEquivalentArray<&T, N> {
         UniqueEntityEquivalentArray(self.0.each_ref())
     }
 }

crates/bevy_ecs/src/entity/unique_slice.rs

@@ -1659,7 +1659,7 @@ impl<'a, T: EntityEquivalent + 'a, I: Iterator<Item = &'a [T]>>
     ///
     /// All elements in each of the slices must be unique.
     #[inline]
-    pub unsafe fn from_slice_iter_unchecked(iter: I) -> Self {
+    pub const unsafe fn from_slice_iter_unchecked(iter: I) -> Self {
         Self { iter }
     }
 
@@ -1671,7 +1671,7 @@ impl<'a, T: EntityEquivalent + 'a, I: Iterator<Item = &'a [T]>>
 
     /// Returns a reference to the inner `I`.
     #[inline]
-    pub fn as_inner(&self) -> &I {
+    pub const fn as_inner(&self) -> &I {
         &self.iter
     }
 
@@ -1682,7 +1682,7 @@ impl<'a, T: EntityEquivalent + 'a, I: Iterator<Item = &'a [T]>>
     /// `self` must always contain an iterator that yields unique elements,
     /// even while this reference is live.
     #[inline]
-    pub unsafe fn as_mut_inner(&mut self) -> &mut I {
+    pub const unsafe fn as_mut_inner(&mut self) -> &mut I {
         &mut self.iter
     }
 }
@@ -1853,7 +1853,7 @@ impl<'a, T: EntityEquivalent + 'a, I: Iterator<Item = &'a mut [T]>>
     ///
     /// All elements in each of the slices must be unique.
     #[inline]
-    pub unsafe fn from_mut_slice_iter_unchecked(iter: I) -> Self {
+    pub const unsafe fn from_mut_slice_iter_unchecked(iter: I) -> Self {
         Self { iter }
     }
 
@@ -1865,7 +1865,7 @@ impl<'a, T: EntityEquivalent + 'a, I: Iterator<Item = &'a mut [T]>>
 
     /// Returns a reference to the inner `I`.
     #[inline]
-    pub fn as_inner(&self) -> &I {
+    pub const fn as_inner(&self) -> &I {
         &self.iter
     }
 
@@ -1876,7 +1876,7 @@ impl<'a, T: EntityEquivalent + 'a, I: Iterator<Item = &'a mut [T]>>
     /// `self` must always contain an iterator that yields unique elements,
     /// even while this reference is live.
     #[inline]
-    pub unsafe fn as_mut_inner(&mut self) -> &mut I {
+    pub const unsafe fn as_mut_inner(&mut self) -> &mut I {
         &mut self.iter
     }
 }