doc: fixed broken doc links

src/catch/gradual_difficulty.rs

@@ -17,14 +17,14 @@ use super::{
 
 /// Gradually calculate the difficulty attributes of an osu!catch map.
 ///
-/// Note that this struct implements [`Iterator`](std::iter::Iterator).
+/// Note that this struct implements [`Iterator`].
-/// On every call of [`Iterator::next`](std::iter::Iterator::next), the map's next fruit or droplet
+/// On every call of [`Iterator::next`], the map's next fruit or droplet
 /// will be processed and the [`CatchDifficultyAttributes`] will be updated and returned.
 ///
 /// Note that it does not return attributes after a tiny droplet. Only for fruits and droplets.
 ///
 /// If you want to calculate performance attributes, use
-/// [`CatchGradualPerformanceAttributes`](crate::catch::CatchGradualPerformance) instead.
+/// [`CatchGradualPerformance`](crate::catch::CatchGradualPerformance) instead.
 ///
 /// # Example
 ///

src/catch/gradual_performance.rs

@@ -4,11 +4,9 @@ use super::{CatchGradualDifficulty, CatchPerformanceAttributes, CatchScoreState}
 
 /// Gradually calculate the performance attributes of an osu!catch map.
 ///
-/// After each hit object you can call
+/// After each hit object you can call [`next`](`CatchGradualPerformance::next`)
-/// [`next`](`CatchGradualPerformanceAttributes::next`)
 /// and it will return the resulting current [`CatchPerformanceAttributes`].
-/// To process multiple objects at once, use
+/// To process multiple objects at once, use [`nth`](`CatchGradualPerformance::nth`) instead.
-/// [`nth`](`CatchGradualPerformanceAttributes::nth`) instead.
 ///
 /// Both methods require a [`CatchScoreState`] that contains the current
 /// hitresults as well as the maximum combo so far.
@@ -16,8 +14,7 @@ use super::{CatchGradualDifficulty, CatchPerformanceAttributes, CatchScoreState}
 /// Note that neither hits nor misses of tiny droplets require
 /// to be processed. Only fruits and droplets do.
 ///
-/// If you only want to calculate difficulty attributes use
+/// If you only want to calculate difficulty attributes use [`CatchGradualDifficulty`] instead.
-/// [`CatchGradualDifficultyAttributes`](crate::catch::CatchGradualDifficulty) instead.
 ///
 /// # Example
 ///

src/catch/score_state.rs

@@ -1,7 +1,5 @@
 /// Aggregation for a score's current state i.e. what was the
 /// maximum combo so far and what are the current hitresults.
-///
-/// This struct is used for [`CatchGradualPerformanceAttributes`].
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
 pub struct CatchScoreState {
     /// Maximum combo that the score has had so far.

src/gradual.rs

@@ -11,7 +11,7 @@ use crate::{
 /// Gradually calculate the difficulty attributes on maps of any mode.
 ///
 /// Note that this struct implements [`Iterator`].
-/// On every call of [`Iterator::next`](Iterator::next), the map's next hit object will
+/// On every call of [`Iterator::next`], the map's next hit object will
 /// be processed and the [`DifficultyAttributes`] will be updated and returned.
 ///
 /// If you want to calculate performance attributes, use [`GradualPerformance`] instead.
@@ -89,10 +89,9 @@ impl Iterator for GradualDifficulty<'_> {
 
 /// Gradually calculate the performance attributes on maps of any mode.
 ///
-/// After each hit object you can call [`next`](`GradualPerformanceAttributes::next`)
+/// After each hit object you can call [`next`](`GradualPerformance::next`)
 /// and it will return the resulting current [`PerformanceAttributes`].
-/// To process multiple objects at once, use
+/// To process multiple objects at once, use [`nth`](`GradualPerformance::nth`) instead.
-/// [`nth`](`GradualPerformanceAttributes::nth`) instead.
 ///
 /// Both methods require a [`ScoreState`] that contains the current hitresults
 /// as well as the maximum combo so far or just the current score for osu!mania.
@@ -100,9 +99,8 @@ impl Iterator for GradualDifficulty<'_> {
 /// and should be updated properly.
 ///
 /// Alternatively, you can match on the map's mode yourself and use the gradual
-/// performance attribute struct for the corresponding mode, i.e.
+/// performance attribute struct for the corresponding mode, i.e. [`OsuGradualPerformance`],
-/// [`OsuGradualPerformance`], [`TaikoGradualPerformance`],
+/// [`TaikoGradualPerformance`], [`CatchGradualPerformance`], or [`ManiaGradualPerformance`].
-/// [`CatchGradualPerformance`], or [`ManiaGradualPerformance`].
 ///
 /// If you only want to calculate difficulty attributes use [`GradualDifficulty`] instead.
 ///

src/lib.rs

@@ -168,7 +168,7 @@
 //! | `async_std` | Beatmap parsing will be async through [async-std](https://github.com/async-rs/async-std) |
 //!
 
-#![cfg_attr(docsrs, feature(doc_cfg), deny(broken_intra_doc_links))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 #![deny(
     clippy::all,
     nonstandard_style,
@@ -176,7 +176,8 @@
     unused,
     warnings,
     missing_debug_implementations,
-    missing_docs
+    missing_docs,
+    rustdoc::broken_intra_doc_links
 )]
 
 /// Everything about osu!catch.

src/mania/gradual_difficulty.rs

@@ -19,11 +19,11 @@ use super::{
 /// Gradually calculate the difficulty attributes of an osu!mania map.
 ///
 /// Note that this struct implements [`Iterator`].
-/// On every call of [`Iterator::next`](Iterator::next), the map's next hit object will
+/// On every call of [`Iterator::next`], the map's next hit object will
 /// be processed and the [`ManiaDifficultyAttributes`] will be updated and returned.
 ///
 /// If you want to calculate performance attributes, use
-/// [`ManiaGradualPerformanceAttributes`](crate::mania::ManiaGradualPerformance) instead.
+/// [`ManiaGradualPerformance`](crate::mania::ManiaGradualPerformance) instead.
 ///
 /// # Example
 ///

src/mania/gradual_performance.rs

@@ -6,10 +6,9 @@ use super::{ManiaGradualDifficulty, ManiaPerformanceAttributes, ManiaScoreState}
 
 /// Gradually calculate the performance attributes of an osu!mania map.
 ///
-/// After each hit object you can call [`next`](`ManiaGradualPerformanceAttributes::next`)
+/// After each hit object you can call [`next`](`ManiaGradualPerformance::next`)
 /// and it will return the resulting current [`ManiaPerformanceAttributes`].
-/// To process multiple objects at once, use
+/// To process multiple objects at once, use [`nth`](`ManiaGradualPerformance::nth`) instead.
-/// [`nth`](`ManiaGradualPerformanceAttributes::nth`) instead.
 ///
 /// Both methods require a play's current score so far.
 /// Be sure the given score is adjusted with respect to mods.

src/mania/score_state.rs

@@ -1,6 +1,4 @@
 /// Aggregation for a score's current state i.e. what are the current hitresults.
-///
-/// This struct is used for [`ManiaGradualPerformanceAttributes`](crate::mania::ManiaGradualPerformance).
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
 pub struct ManiaScoreState {
     /// Amount of current 320s.

src/osu/gradual_difficulty.rs

@@ -21,12 +21,12 @@ use super::{
 
 /// Gradually calculate the difficulty attributes of an osu!standard map.
 ///
-/// Note that this struct implements [`Iterator`](std::iter::Iterator).
+/// Note that this struct implements [`Iterator`].
-/// On every call of [`Iterator::next`](std::iter::Iterator::next), the map's next hit object will
+/// On every call of [`Iterator::next`], the map's next hit object will
 /// be processed and the [`OsuDifficultyAttributes`] will be updated and returned.
 ///
 /// If you want to calculate performance attributes, use
-/// [`OsuGradualPerformanceAttributes`](crate::osu::OsuGradualPerformance) instead.
+/// [`OsuGradualPerformance`](crate::osu::OsuGradualPerformance) instead.
 ///
 /// # Example
 ///

src/osu/gradual_performance.rs

@@ -6,10 +6,9 @@ use super::{OsuGradualDifficulty, OsuPerformanceAttributes, OsuScoreState};
 
 /// Gradually calculate the performance attributes of an osu!standard map.
 ///
-/// After each hit object you can call [`next`](`OsuGradualPerformanceAttributes::next`)
+/// After each hit object you can call [`next`](`OsuGradualPerformance::next`)
 /// and it will return the resulting current [`OsuPerformanceAttributes`].
-/// To process multiple objects at once, use
+/// To process multiple objects at once, use [`nth`](`OsuGradualPerformance::nth`) instead.
-/// [`nth`](`OsuGradualPerformanceAttributes::nth`) instead.
 ///
 /// Both methods require an [`OsuScoreState`] that contains the current
 /// hitresults as well as the maximum combo so far.

src/osu/score_state.rs

@@ -1,7 +1,5 @@
 /// Aggregation for a score's current state i.e. what was the
 /// maximum combo so far and what are the current hitresults.
-///
-/// This struct is used for [`OsuGradualPerformanceAttributes`](crate::osu::OsuGradualPerformance).
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
 pub struct OsuScoreState {
     /// Maximum combo that the score has had so far.

src/parse/mod.rs

@@ -919,7 +919,7 @@ impl Beatmap {
     /// Parse a beatmap from a `.osu` file.
     ///
     /// As argument you can give anything that implements [`std::io::Read`].
-    /// You'll likely want to pass (a reference of) a [`File`](std::fs::File)
+    /// You'll likely want to pass (a reference of) a [`File`]
     /// or the file's content as a slice of bytes (`&[u8]`).
     pub fn parse<R: Read>(input: R) -> ParseResult<Self> {
         parse_body!(input)
@@ -967,7 +967,7 @@ impl Beatmap {
 
     /// Pass the path to a `.osu` file.
     ///
-    /// Useful when you don't want to create the [`File`](std::fs::File) manually.
+    /// Useful when you don't want to create the [`File`] manually.
     /// If you have the file lying around already though (and plan on re-using it),
     /// passing `&file` to [`parse`](Beatmap::parse) should be preferred.
     pub fn from_path<P: AsRef<Path>>(path: P) -> ParseResult<Self> {

src/score_state.rs

@@ -7,7 +7,7 @@ use crate::{
 /// the maximum combo so far, what are the current
 /// hitresults and what is the current score.
 ///
-/// This struct is used for [`GradualPerformanceAttributes`].
+/// This struct is used for [`GradualPerformance`](crate::GradualPerformance).
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
 pub struct ScoreState {
     /// Maximum combo that the score has had so far.

src/taiko/gradual_difficulty.rs

@@ -14,12 +14,12 @@ use super::{
 
 /// Gradually calculate the difficulty attributes of an osu!taiko map.
 ///
-/// Note that this struct implements [`Iterator`](std::iter::Iterator).
+/// Note that this struct implements [`Iterator`].
-/// On every call of [`Iterator::next`](std::iter::Iterator::next), the map's next hit object will
+/// On every call of [`Iterator::next`], the map's next hit object will
 /// be processed and the [`TaikoDifficultyAttributes`] will be updated and returned.
 ///
 /// If you want to calculate performance attributes, use
-/// [`TaikoGradualPerformanceAttributes`](crate::taiko::TaikoGradualPerformance) instead.
+/// [`TaikoGradualPerformance`](crate::taiko::TaikoGradualPerformance) instead.
 ///
 /// # Example
 ///

src/taiko/gradual_performance.rs

@@ -6,10 +6,9 @@ use super::{TaikoGradualDifficulty, TaikoPerformanceAttributes};
 
 /// Gradually calculate the performance attributes of an osu!taiko map.
 ///
-/// After each hit object you can call [`next`](`TaikoGradualPerformanceAttributes::next`)
+/// After each hit object you can call [`next`](`TaikoGradualPerformance::next`)
 /// and it will return the resulting current [`TaikoPerformanceAttributes`].
-/// To process multiple objects at once, use
+/// To process multiple objects at once, use [`nth`](`TaikoGradualPerformance::nth`) instead.
-/// [`nth`](`TaikoGradualPerformanceAttributes::nth`) instead.
 ///
 /// Both methods require a [`TaikoScoreState`] that contains the current
 /// hitresults as well as the maximum combo so far.

src/taiko/score_state.rs

@@ -1,7 +1,5 @@
 /// Aggregation for a score's current state i.e. what was the
 /// maximum combo so far and what are the current hitresults.
-///
-/// This struct is used for [`TaikoGradualPerformanceAttributes`](crate::taiko::TaikoGradualPerformance).
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
 pub struct TaikoScoreState {
     /// Maximum combo that the score has had so far.