Fix some documentation after new stable doc lints

Author: nakedible

crates/bevy_time/src/fixed.rs

@@ -12,8 +12,7 @@ use crate::{time::Time, virt::Virtual, FixedUpdate};
 /// It is automatically inserted as a resource by
 /// [`TimePlugin`](crate::TimePlugin) and updated based on
 /// [`Time<Virtual>`](Virtual). The fixed clock is automatically set as the
-/// generic [`Time`] resource during [`FixedUpdate`](bevy_app::FixedUpdate)
-/// schedule processing.
+/// generic [`Time`] resource during [`FixedUpdate`] schedule processing.
 ///
 /// The fixed timestep clock advances in fixed-size increments, which is
 /// extremely useful for writing logic (like physics) that should have
@@ -27,13 +26,12 @@ use crate::{time::Time, virt::Virtual, FixedUpdate};
 /// frame). Additionally, the value is a power of two which losslessly converts
 /// into [`f32`] and [`f64`].
 ///
-/// To run a system on a fixed timestep, add it to the
-/// [`FixedUpdate`](bevy_app::FixedUpdate) schedule. This schedule is run a
-/// number of times between [`PreUpdate`](bevy_app::PreUpdate) and
-/// [`Update`](bevy_app::Update) according to the accumulated
-/// [`overstep()`](Time::overstep) time divided by the
-/// [`timestep()`](Time::timestep). This means the schedule may run 0, 1 or more
-/// times during a single update (which typically corresponds to a rendered
+/// To run a system on a fixed timestep, add it to the [`FixedUpdate`] schedule.
+/// This schedule is run a number of times between
+/// [`PreUpdate`](bevy_app::PreUpdate) and [`Update`](bevy_app::Update)
+/// according to the accumulated [`overstep()`](Time::overstep) time divided by
+/// the [`timestep()`](Time::timestep). This means the schedule may run 0, 1 or
+/// more times during a single update (which typically corresponds to a rendered
 /// frame).
 ///
 /// `Time<Fixed>` and the generic [`Time`] resource will report a
@@ -45,21 +43,20 @@ use crate::{time::Time, virt::Virtual, FixedUpdate};
 /// means it is affected by [`pause()`](Time::pause),
 /// [`set_relative_speed()`](Time::set_relative_speed) and
 /// [`set_max_delta()`](Time::set_max_delta) from virtual time. If the virtual
-/// clock is paused, the [`FixedUpdate`](bevy_app::FixedUpdate) schedule will
-/// not run. It is guaranteed that the [`elapsed()`](Time::elapsed) time in
-/// `Time<Fixed>` is always between the previous `elapsed()` and the current
-/// `elapsed()` value in `Time<Virtual>`, so the values are compatible.
+/// clock is paused, the [`FixedUpdate`] schedule will not run. It is guaranteed
+/// that the [`elapsed()`](Time::elapsed) time in `Time<Fixed>` is always
+/// between the previous `elapsed()` and the current `elapsed()` value in
+/// `Time<Virtual>`, so the values are compatible.
 ///
 /// Changing the timestep size while the game is running should not normally be
 /// done, as having a regular interval is the point of this schedule, but it may
 /// be necessary for effects like "bullet-time" if the normal granularity of the
 /// fixed timestep is too big for the slowed down time. In this case,
 /// [`set_timestep()`](Time::set_timestep) and be called to set a new value. The
-/// new value will be used immediately for the next run of the
-/// [`FixedUpdate`](bevy_app::FixedUpdate) schedule, meaning that it will affect
-/// the [`delta()`](Time::delta) value for the very next
-/// [`FixedUpdate`](bevy_app::FixedUpdate), even if it is still during the same
-/// frame. Any [`overstep()`](Time::overstep) present in the accumulator will be
+/// new value will be used immediately for the next run of the [`FixedUpdate`]
+/// schedule, meaning that it will affect the [`delta()`](Time::delta) value for
+/// the very next [`FixedUpdate`], even if it is still during the same frame.
+/// Any [`overstep()`](Time::overstep) present in the accumulator will be
 /// processed according to the new [`timestep()`](Time::timestep) value.
 #[derive(Debug, Copy, Clone, Reflect)]
 pub struct Fixed {
@@ -71,8 +68,7 @@ impl Time<Fixed> {
     /// Corresponds to 64 Hz.
     const DEFAULT_TIMESTEP: Duration = Duration::from_micros(15625);
 
-    /// Return new fixed time clock with given timestep as
-    /// [`Duration`](std::time::Duration)
+    /// Return new fixed time clock with given timestep as [`Duration`]
     ///
     /// # Panics
     ///
@@ -113,7 +109,7 @@ impl Time<Fixed> {
     }
 
     /// Sets the amount of virtual time that must pass before the fixed timestep
-    /// schedule is run again, as [`Duration`](std::time::Duration).
+    /// schedule is run again, as [`Duration`].
     ///
     /// Takes effect immediately on the next run of the schedule, respecting
     /// what is currently in [`Self::overstep`].
@@ -134,9 +130,8 @@ impl Time<Fixed> {
     /// Sets the amount of virtual time that must pass before the fixed timestep
     /// schedule is run again, as seconds.
     ///
-    /// Timestep is stored as a [`Duration`](std::time::Duration), which has
-    /// fixed nanosecond resolution and will be converted from the floating
-    /// point number.
+    /// Timestep is stored as a [`Duration`], which has fixed nanosecond
+    /// resolution and will be converted from the floating point number.
     ///
     /// Takes effect immediately on the next run of the schedule, respecting
     /// what is currently in [`Self::overstep`].
@@ -157,8 +152,8 @@ impl Time<Fixed> {
     /// Sets the amount of virtual time that must pass before the fixed timestep
     /// schedule is run again, as frequency.
     ///
-    /// The timestep value is set to `1 / hz`, converted to a
-    /// [`Duration`](std::time::Duration) which has fixed nanosecond resolution.
+    /// The timestep value is set to `1 / hz`, converted to a [`Duration`] which
+    /// has fixed nanosecond resolution.
     ///
     /// Takes effect immediately on the next run of the schedule, respecting
     /// what is currently in [`Self::overstep`].
@@ -174,7 +169,7 @@ impl Time<Fixed> {
     }
 
     /// Returns the amount of overstep time accumulated toward new steps, as
-    /// [`Duration`](std::time::Duration).
+    /// [`Duration`].
     #[inline]
     pub fn overstep(&self) -> Duration {
         self.context().overstep
@@ -221,8 +216,8 @@ impl Default for Fixed {
     }
 }
 
-/// Runs [`FixedUpdate`](bevy_app::FixedUpdate) zero or more times based on
-/// delta of [`Time<Virtual>`](Virtual) and [`Time::overstep`]
+/// Runs [`FixedUpdate`] zero or more times based on delta of
+/// [`Time<Virtual>`](Virtual) and [`Time::overstep`]
 pub fn run_fixed_update_schedule(world: &mut World) {
     let delta = world.resource::<Time<Virtual>>().delta();
     world.resource_mut::<Time<Fixed>>().accumulate(delta);

crates/bevy_time/src/real.rs

@@ -65,7 +65,7 @@ impl Time<Real> {
         self.update_with_instant(instant);
     }
 
-    /// Updates time with a specified [`Duration`](std::time::Duration).
+    /// Updates time with a specified [`Duration`].
     ///
     /// This method is provided for use in tests.
     ///

crates/bevy_time/src/time.rs

@@ -2,27 +2,28 @@ use bevy_ecs::{reflect::ReflectResource, system::Resource};
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_utils::Duration;
 
-/// A generic clock resource that tracks how much it has advanced since its previous
-/// update and since its creation.
+/// A generic clock resource that tracks how much it has advanced since its
+/// previous update and since its creation.
 ///
 /// Multiple instances of this resource are inserted automatically by
 /// [`TimePlugin`](crate::TimePlugin):
 ///
 /// - [`Time<Real>`](crate::real::Real) tracks real wall-clock time elapsed.
-/// - [`Time<Virtual>`](crate::virt::Virtual) tracks virtual game time that may be paused or scaled.
-/// - [`Time<Fixed>`](crate::fixed::Fixed) tracks fixed timesteps based on virtual time.
-/// - [`Time`] is a generic clock that corresponds to "current" or "default" time for systems. It
-///   contains [`Time<Virtual>`](crate::virt::Virtual) except inside the
-///   [`FixedUpdate`](bevy_app::FixedUpdate) schedule when it contains
-///   [`Time<Fixed>`](crate::fixed::Fixed).
+/// - [`Time<Virtual>`](crate::virt::Virtual) tracks virtual game time that may
+///   be paused or scaled.
+/// - [`Time<Fixed>`](crate::fixed::Fixed) tracks fixed timesteps based on
+///   virtual time.
+/// - [`Time`] is a generic clock that corresponds to "current" or "default"
+///   time for systems. It contains [`Time<Virtual>`](crate::virt::Virtual)
+///   except inside the [`FixedUpdate`](bevy_app::FixedUpdate) schedule when it
+///   contains [`Time<Fixed>`](crate::fixed::Fixed).
 ///
-/// The time elapsed since the previous time this clock was advanced is saved
-/// as [`delta()`](Time::delta) and the total amount of time the clock has
-/// advanced is saved as [`elapsed()`](Time::elapsed). Both are represented
-/// as exact [`Duration`](std::time::Duration) values with fixed nanosecond
-/// precision. The clock does not support time moving backwards, but it can be
-/// updated with [`Duration::ZERO`](std::time::Duration::ZERO) which will set
-/// [`delta()`](Time::delta) to zero.
+/// The time elapsed since the previous time this clock was advanced is saved as
+/// [`delta()`](Time::delta) and the total amount of time the clock has advanced
+/// is saved as [`elapsed()`](Time::elapsed). Both are represented as exact
+/// [`Duration`] values with fixed nanosecond precision. The clock does not
+/// support time moving backwards, but it can be updated with [`Duration::ZERO`]
+/// which will set [`delta()`](Time::delta) to zero.
 ///
 /// These values are also available in seconds as `f32` via
 /// [`delta_seconds()`](Time::delta_seconds) and
@@ -34,19 +35,19 @@ use bevy_utils::Duration;
 /// is `f32`, it will exhibit gradual precision loss. For applications that
 /// require an `f32` value but suffer from gradual precision loss there is
 /// [`elapsed_seconds_wrapped()`](Time::elapsed_seconds_wrapped) available. The
-/// same wrapped value is also available as [`Duration`](std::time::Duration)
-/// and `f64` for consistency. The wrap period is by default 1 hour, and can be
-/// set by [`set_wrap_period()`](Time::set_wrap_period).
+/// same wrapped value is also available as [`Duration`] and `f64` for
+/// consistency. The wrap period is by default 1 hour, and can be set by
+/// [`set_wrap_period()`](Time::set_wrap_period).
 ///
 /// # Accessing clocks
 ///
 /// By default, any systems requiring current [`delta()`](Time::delta) or
 /// [`elapsed()`](Time::elapsed) should use `Res<Time>` to access the default
 /// time configured for the program. By default, this refers to
-/// [`Time<Virtual>`](crate::virt::Virtual) except during
-/// the [`FixedUpdate`](bevy_app::FixedUpdate) schedule when it refers to
-/// [`Time<Fixed>`](crate::fixed::Fixed). This ensures your system can
-/// be used either in [`Update`](bevy_app::Update) or
+/// [`Time<Virtual>`](crate::virt::Virtual) except during the
+/// [`FixedUpdate`](bevy_app::FixedUpdate) schedule when it refers to
+/// [`Time<Fixed>`](crate::fixed::Fixed). This ensures your system can be used
+/// either in [`Update`](bevy_app::Update) or
 /// [`FixedUpdate`](bevy_app::FixedUpdate) schedule depending on what is needed.
 ///
 /// ```
@@ -140,10 +141,9 @@ use bevy_utils::Duration;
 /// both your context and the generic time part, it's probably simplest to add a
 /// custom trait for them and implement it for `Time<Custom>`.
 ///
-/// Your context struct will need to implement the
-/// [`Default`](std::default::Default) trait because [`Time`] structures support
-/// reflection. It also makes initialization trivial by being able to call
-/// `app.init_resource::<Time<Custom>>()`.
+/// Your context struct will need to implement the [`Default`] trait because
+/// [`Time`] structures support reflection. It also makes initialization trivial
+/// by being able to call `app.init_resource::<Time<Custom>>()`.
 ///
 /// You can also replace the "generic" `Time` clock resource if the "default"
 /// time for your game should not be the default virtual time provided. You can
@@ -215,8 +215,7 @@ impl<T: Default> Time<T> {
     ///
     /// The added duration will be returned by [`Self::delta`] and
     /// [`Self::elapsed`] will be increased by the duration. Adding
-    /// [`Duration::ZERO`](std::time::Duration::ZERO) is allowed and will set
-    /// [`Self::delta`] to zero.
+    /// [`Duration::ZERO`] is allowed and will set [`Self::delta`] to zero.
     pub fn advance_by(&mut self, delta: Duration) {
         self.delta = delta;
         self.delta_seconds = self.delta.as_secs_f32();

crates/bevy_time/src/virt.rs

@@ -82,8 +82,7 @@ impl Time<Virtual> {
     /// Equal to 250 milliseconds.
     const DEFAULT_MAX_DELTA: Duration = Duration::from_millis(250);
 
-    /// Create new virtual clock with given maximum delta step
-    /// [`Duration`](std::time::Duration)
+    /// Create new virtual clock with given maximum delta step [`Duration`]
     ///
     /// # Panics
     ///
@@ -95,7 +94,7 @@ impl Time<Virtual> {
     }
 
     /// Returns the maximum amount of time that can be added to this clock by a
-    /// single update, as [`Duration`](std::time::Duration).
+    /// single update, as [`Duration`].
     ///
     /// This is the maximum value [`Self::delta()`] will return and also to
     /// maximum time [`Self::elapsed()`] will be increased by in a single
@@ -112,7 +111,7 @@ impl Time<Virtual> {
     }
 
     /// Sets the maximum amount of time that can be added to this clock by a
-    /// single update, as [`Duration`](std::time::Duration).
+    /// single update, as [`Duration`].
     ///
     /// This is the maximum value [`Self::delta()`] will return and also to
     /// maximum time [`Self::elapsed()`] will be increased by in a single
@@ -124,11 +123,12 @@ impl Time<Virtual> {
     /// gameplay bugs or having to suddenly simulate all the intervening time.
     ///
     /// If no updates happen for an extended amount of time, this limit prevents
-    /// having a sudden, huge advance all at once. This also indirectly limits the
-    /// maximum number of fixed update steps that can run in a single update.
+    /// having a sudden, huge advance all at once. This also indirectly limits
+    /// the maximum number of fixed update steps that can run in a single
+    /// update.
     ///
-    /// The default value is 250 milliseconds. If you want to disable this feature,
-    /// set the value to [`Duration::MAX`](std::time::Duration).
+    /// The default value is 250 milliseconds. If you want to disable this
+    /// feature, set the value to [`Duration::MAX`].
     ///
     /// # Panics
     ///