Fix uses of "it's" vs "its". (#13033)

Grammar changes only.

Author: targrub

crates/bevy_asset/src/processor/mod.rs

@@ -408,7 +408,7 @@ impl AssetProcessor {
         infos.remove(&asset_path).await;
     }
 
-    /// Handles a renamed source asset by moving it's processed results to the new location and updating in-memory paths + metadata.
+    /// Handles a renamed source asset by moving its processed results to the new location and updating in-memory paths + metadata.
     /// This will cause direct path dependencies to break.
     async fn handle_renamed_asset(&self, source: &AssetSource, old: PathBuf, new: PathBuf) {
         let mut infos = self.data.asset_infos.write().await;

crates/bevy_ecs/examples/resources.rs

@@ -1,4 +1,4 @@
-//! In this example we add a counter resource and increase it's value in one system,
+//! In this example we add a counter resource and increase its value in one system,
 //! while a different system prints the current count to the console.
 
 use bevy_ecs::prelude::*;

crates/bevy_ecs/src/bundle.rs

@@ -178,7 +178,7 @@ pub trait DynamicBundle {
 
 // SAFETY:
 // - `Bundle::component_ids` calls `ids` for C's component id (and nothing else)
-// - `Bundle::get_components` is called exactly once for C and passes the component's storage type based on it's associated constant.
+// - `Bundle::get_components` is called exactly once for C and passes the component's storage type based on its associated constant.
 // - `Bundle::from_components` calls `func` exactly once for C, which is the exact value returned by `Bundle::component_ids`.
 unsafe impl<C: Component> Bundle for C {
     fn component_ids(
@@ -990,10 +990,10 @@ impl Bundles {
             T::component_ids(components, storages, &mut |id| component_ids.push(id));
             let id = BundleId(bundle_infos.len());
             let bundle_info =
-                // SAFETY: T::component_id ensures its:
-                // - info was created
+                // SAFETY: T::component_id ensures:
+                // - its info was created
                 // - appropriate storage for it has been initialized.
-                // - was created in the same order as the components in T
+                // - it was created in the same order as the components in T
                 unsafe { BundleInfo::new(std::any::type_name::<T>(), components, component_ids, id) };
             bundle_infos.push(bundle_info);
             id

crates/bevy_ecs/src/component.rs

@@ -154,7 +154,7 @@ pub trait Component: Send + Sync + 'static {
     /// A constant indicating the storage type used for this component.
     const STORAGE_TYPE: StorageType;
 
-    /// Called when registering this component, allowing mutable access to it's [`ComponentHooks`].
+    /// Called when registering this component, allowing mutable access to its [`ComponentHooks`].
     fn register_component_hooks(_hooks: &mut ComponentHooks) {}
 }
 
@@ -182,7 +182,7 @@ pub enum StorageType {
 /// The type used for [`Component`] lifecycle hooks such as `on_add`, `on_insert` or `on_remove`
 pub type ComponentHook = for<'w> fn(DeferredWorld<'w>, Entity, ComponentId);
 
-/// Lifecycle hooks for a given [`Component`], stored in it's [`ComponentInfo`]
+/// Lifecycle hooks for a given [`Component`], stored in its [`ComponentInfo`]
 #[derive(Debug, Clone, Default)]
 pub struct ComponentHooks {
     pub(crate) on_add: Option<ComponentHook>,
@@ -193,7 +193,7 @@ pub struct ComponentHooks {
 impl ComponentHooks {
     /// Register a [`ComponentHook`] that will be run when this component is added to an entity.
     /// An `on_add` hook will always run before `on_insert` hooks. Spawning an entity counts as
-    /// adding all of it's components.
+    /// adding all of its components.
     ///
     /// Will panic if the component already has an `on_add` hook
     pub fn on_add(&mut self, hook: ComponentHook) -> &mut Self {
@@ -212,7 +212,7 @@ impl ComponentHooks {
     }
 
     /// Register a [`ComponentHook`] that will be run when this component is removed from an entity.
-    /// Despawning an entity counts as removing all of it's components.
+    /// Despawning an entity counts as removing all of its components.
     ///
     /// Will panic if the component already has an `on_remove` hook
     pub fn on_remove(&mut self, hook: ComponentHook) -> &mut Self {

crates/bevy_ecs/src/query/state.rs

@@ -171,7 +171,7 @@ impl<D: QueryData, F: QueryFilter> QueryState<D, F> {
 
     /// Creates a new [`QueryState`] but does not populate it with the matched results from the World yet
     ///
-    /// `new_archetype` and it's variants must be called on all of the World's archetypes before the
+    /// `new_archetype` and its variants must be called on all of the World's archetypes before the
     /// state can return valid query results.
     fn new_uninitialized(world: &mut World) -> Self {
         let fetch_state = D::init_state(world);
@@ -208,7 +208,7 @@ impl<D: QueryData, F: QueryFilter> QueryState<D, F> {
         }
     }
 
-    /// Creates a new [`QueryState`] from a given [`QueryBuilder`] and inherits it's [`FilteredAccess`].
+    /// Creates a new [`QueryState`] from a given [`QueryBuilder`] and inherits its [`FilteredAccess`].
     pub fn from_builder(builder: &mut QueryBuilder<D, F>) -> Self {
         let mut fetch_state = D::init_state(builder.world_mut());
         let filter_state = F::init_state(builder.world_mut());

crates/bevy_ecs/src/storage/blob_vec.rs

@@ -165,7 +165,7 @@ impl BlobVec {
             // - the layout of the ptr was `array_layout(self.item_layout, self.capacity)`
             // - `item_layout.size() > 0` and `new_capacity > 0`, so the layout size is non-zero
             // - "new_size, when rounded up to the nearest multiple of layout.align(), must not overflow (i.e., the rounded value must be less than usize::MAX)",
-            // since the item size is always a multiple of its align, the rounding cannot happen
+            // since the item size is always a multiple of its alignment, the rounding cannot happen
             // here and the overflow is handled in `array_layout`
             unsafe {
                 std::alloc::realloc(

crates/bevy_ecs/src/storage/resource.rs

@@ -298,7 +298,7 @@ impl<const SEND: bool> Resources<SEND> {
         self.resources.get_mut(component_id)
     }
 
-    /// Fetches or initializes a new resource and returns back it's underlying column.
+    /// Fetches or initializes a new resource and returns back its underlying column.
     ///
     /// # Panics
     /// Will panic if `component_id` is not valid for the provided `components`

crates/bevy_ecs/src/storage/table.rs

@@ -139,7 +139,7 @@ impl TableRow {
 /// Conceptually, a [`Column`] is very similar to a type-erased `Vec<T>`.
 /// It also stores the change detection ticks for its components, kept in two separate
 /// contiguous buffers internally. An element shares its data across these buffers by using the
-/// same index (i.e. the entity at row 3 has it's data at index 3 and its change detection ticks at
+/// same index (i.e. the entity at row 3 has its data at index 3 and its change detection ticks at
 /// index 3). A slice to these contiguous blocks of memory can be fetched
 /// via [`Column::get_data_slice`], [`Column::get_added_ticks_slice`], and
 /// [`Column::get_changed_ticks_slice`].

crates/bevy_ecs/src/system/query.rs

@@ -1366,7 +1366,7 @@ impl<'w, 's, D: QueryData, F: QueryFilter> Query<'w, 's, D, F> {
     ) -> QueryLens<'_, NewD, NewF> {
         // SAFETY:
         // - We have exclusive access to the query
-        // - `self` has correctly captured it's access
+        // - `self` has correctly captured its access
         // - Access is checked to be a subset of the query's access when the state is created.
         let world = unsafe { self.world.world() };
         let state = self.state.transmute_filtered::<NewD, NewF>(world);

crates/bevy_ecs/src/system/system.rs

@@ -176,7 +176,7 @@ impl<In: 'static, Out: 'static> Debug for dyn System<In = In, Out = Out> {
 /// Trait used to run a system immediately on a [`World`].
 ///
 /// # Warning
-/// This function is not an efficient method of running systems and its meant to be used as a utility
+/// This function is not an efficient method of running systems and it's meant to be used as a utility
 /// for testing and/or diagnostics.
 ///
 /// Systems called through [`run_system_once`](RunSystemOnce::run_system_once) do not hold onto any state,