From 91738d804a3b7be1caae1a9b8378c25d30152bcc Mon Sep 17 00:00:00 2001 From: Lzu Tao Date: Mon, 13 Jul 2020 15:50:30 +0000 Subject: [PATCH 1/8] Use intra-doc link on Iterator page --- src/libcore/iter/traits/iterator.rs | 77 ++++++++--------------------- 1 file changed, 21 insertions(+), 56 deletions(-) diff --git a/src/libcore/iter/traits/iterator.rs b/src/libcore/iter/traits/iterator.rs index 692eed80c0252..daf56a0d126a4 100644 --- a/src/libcore/iter/traits/iterator.rs +++ b/src/libcore/iter/traits/iterator.rs @@ -106,8 +106,7 @@ pub trait Iterator { /// again may or may not eventually start returning [`Some(Item)`] again at some /// point. /// - /// [`None`]: ../../std/option/enum.Option.html#variant.None - /// [`Some(Item)`]: ../../std/option/enum.Option.html#variant.Some + /// [`Some(Item)`]: Some /// /// # Examples /// @@ -160,9 +159,7 @@ pub trait Iterator { /// The default implementation returns `(0, `[`None`]`)` which is correct for any /// iterator. /// - /// [`usize`]: ../../std/primitive.usize.html - /// [`Option`]: ../../std/option/enum.Option.html - /// [`None`]: ../../std/option/enum.Option.html#variant.None + /// [`usize`]: type@usize /// /// # Examples /// @@ -214,8 +211,6 @@ pub trait Iterator { /// called at least once even if the iterator does not have any elements. /// /// [`next`]: #tymethod.next - /// [`None`]: ../../std/option/enum.Option.html#variant.None - /// [`Some`]: ../../std/option/enum.Option.html#variant.Some /// /// # Overflow Behavior /// @@ -229,7 +224,7 @@ pub trait Iterator { /// This function might panic if the iterator has more than [`usize::MAX`] /// elements. /// - /// [`usize::MAX`]: ../../std/usize/constant.MAX.html + /// [`usize::MAX`]: crate::usize::MAX /// /// # Examples /// @@ -263,8 +258,6 @@ pub trait Iterator { /// doing so, it keeps track of the current element. After [`None`] is /// returned, `last()` will then return the last element it saw. /// - /// [`None`]: ../../std/option/enum.Option.html#variant.None - /// /// # Examples /// /// Basic usage: @@ -303,8 +296,6 @@ pub trait Iterator { /// `nth()` will return [`None`] if `n` is greater than or equal to the length of the /// iterator. /// - /// [`None`]: ../../std/option/enum.Option.html#variant.None - /// /// # Examples /// /// Basic usage: @@ -537,9 +528,8 @@ pub trait Iterator { /// assert_eq!((2, 'o'), zipper[2]); /// ``` /// - /// [`enumerate`]: trait.Iterator.html#method.enumerate - /// [`next`]: ../../std/iter/trait.Iterator.html#tymethod.next - /// [`None`]: ../../std/option/enum.Option.html#variant.None + /// [`enumerate`]: #method.enumerate + /// [`next`]: #tymethod.next #[inline] #[stable(feature = "rust1", since = "1.0.0")] fn zip(self, other: U) -> Zip @@ -568,7 +558,7 @@ pub trait Iterator { /// more idiomatic to use [`for`] than `map()`. /// /// [`for`]: ../../book/ch03-05-control-flow.html#looping-through-a-collection-with-for - /// [`FnMut`]: ../../std/ops/trait.FnMut.html + /// [`FnMut`]: crate::ops::FnMut /// /// # Examples /// @@ -777,9 +767,7 @@ pub trait Iterator { /// assert_eq!(iter.next(), None); /// ``` /// - /// [`Option`]: ../../std/option/enum.Option.html - /// [`Some`]: ../../std/option/enum.Option.html#variant.Some - /// [`None`]: ../../std/option/enum.Option.html#variant.None + /// [`Option`]: Option #[inline] #[stable(feature = "rust1", since = "1.0.0")] fn filter_map(self, f: F) -> FilterMap @@ -812,8 +800,8 @@ pub trait Iterator { /// The returned iterator might panic if the to-be-returned index would /// overflow a [`usize`]. /// - /// [`usize::MAX`]: ../../std/usize/constant.MAX.html - /// [`usize`]: ../../std/primitive.usize.html + /// [`usize`]: type@usize + /// [`usize::MAX`]: crate::usize::MAX /// [`zip`]: #method.zip /// /// # Examples @@ -849,8 +837,8 @@ pub trait Iterator { /// anything other than fetching the next value) of the [`next`] method /// will occur. /// - /// [`peek`]: struct.Peekable.html#method.peek - /// [`next`]: ../../std/iter/trait.Iterator.html#tymethod.next + /// [`peek`]: crate::iter::Peekable::peek + /// [`next`]: #tymethod.next /// /// # Examples /// @@ -1116,8 +1104,6 @@ pub trait Iterator { /// It is also not specified what this iterator returns after the first` None` is returned. /// If you need fused iterator, use [`fuse`]. /// - /// [`Some`]: ../../std/option/enum.Option.html#variant.Some - /// [`None`]: ../../std/option/enum.Option.html#variant.None /// [`fuse`]: #method.fuse #[inline] #[unstable(feature = "iter_map_while", reason = "recently added", issue = "68537")] @@ -1216,8 +1202,6 @@ pub trait Iterator { /// iterator and the return value from the closure, an [`Option`], is /// yielded by the iterator. /// - /// [`Option`]: ../../std/option/enum.Option.html - /// /// # Examples /// /// Basic usage: @@ -1366,8 +1350,7 @@ pub trait Iterator { /// [`Some(T)`] again. `fuse()` adapts an iterator, ensuring that after a /// [`None`] is given, it will always return [`None`] forever. /// - /// [`None`]: ../../std/option/enum.Option.html#variant.None - /// [`Some(T)`]: ../../std/option/enum.Option.html#variant.Some + /// [`Some(T)`]: Some /// /// # Examples /// @@ -1658,10 +1641,9 @@ pub trait Iterator { /// assert_eq!(Ok(vec![1, 3]), result); /// ``` /// - /// [`iter`]: ../../std/iter/trait.Iterator.html#tymethod.next + /// [`iter`]: #tymethod.next /// [`String`]: ../../std/string/struct.String.html - /// [`char`]: ../../std/primitive.char.html - /// [`Result`]: ../../std/result/enum.Result.html + /// [`char`]: type@char #[inline] #[stable(feature = "rust1", since = "1.0.0")] #[must_use = "if you really need to exhaust the iterator, consider `.for_each(drop)` instead"] @@ -2184,8 +2166,7 @@ pub trait Iterator { /// argument is a double reference. You can see this effect in the /// examples below, with `&&x`. /// - /// [`Some(element)`]: ../../std/option/enum.Option.html#variant.Some - /// [`None`]: ../../std/option/enum.Option.html#variant.None + /// [`Some(element)`]: Some /// /// # Examples /// @@ -2331,9 +2312,8 @@ pub trait Iterator { /// This function might panic if the iterator has more than `usize::MAX` /// non-matching elements. /// - /// [`Some(index)`]: ../../std/option/enum.Option.html#variant.Some - /// [`None`]: ../../std/option/enum.Option.html#variant.None - /// [`usize::MAX`]: ../../std/usize/constant.MAX.html + /// [`Some(index)`]: Some + /// [`usize::MAX`]: crate::usize::MAX /// /// # Examples /// @@ -2394,8 +2374,7 @@ pub trait Iterator { /// `rposition()` is short-circuiting; in other words, it will stop /// processing as soon as it finds a `true`. /// - /// [`Some(index)`]: ../../std/option/enum.Option.html#variant.Some - /// [`None`]: ../../std/option/enum.Option.html#variant.None + /// [`Some(index)`]: Some /// /// # Examples /// @@ -2449,8 +2428,6 @@ pub trait Iterator { /// If several elements are equally maximum, the last element is /// returned. If the iterator is empty, [`None`] is returned. /// - /// [`None`]: ../../std/option/enum.Option.html#variant.None - /// /// # Examples /// /// Basic usage: @@ -2477,8 +2454,6 @@ pub trait Iterator { /// If several elements are equally minimum, the first element is /// returned. If the iterator is empty, [`None`] is returned. /// - /// [`None`]: ../../std/option/enum.Option.html#variant.None - /// /// # Examples /// /// Basic usage: @@ -2506,8 +2481,6 @@ pub trait Iterator { /// If several elements are equally maximum, the last element is /// returned. If the iterator is empty, [`None`] is returned. /// - /// [`None`]: ../../std/option/enum.Option.html#variant.None - /// /// # Examples /// /// ``` @@ -2541,8 +2514,6 @@ pub trait Iterator { /// If several elements are equally maximum, the last element is /// returned. If the iterator is empty, [`None`] is returned. /// - /// [`None`]: ../../std/option/enum.Option.html#variant.None - /// /// # Examples /// /// ``` @@ -2570,8 +2541,6 @@ pub trait Iterator { /// If several elements are equally minimum, the first element is /// returned. If the iterator is empty, [`None`] is returned. /// - /// [`None`]: ../../std/option/enum.Option.html#variant.None - /// /// # Examples /// /// ``` @@ -2605,8 +2574,6 @@ pub trait Iterator { /// If several elements are equally minimum, the first element is /// returned. If the iterator is empty, [`None`] is returned. /// - /// [`None`]: ../../std/option/enum.Option.html#variant.None - /// /// # Examples /// /// ``` @@ -2747,7 +2714,7 @@ pub trait Iterator { /// This is useful when you have an iterator over `&T`, but you need an /// iterator over `T`. /// - /// [`clone`]: ../../std/clone/trait.Clone.html#tymethod.clone + /// [`clone`]: crate::clone::Clone::clone /// /// # Examples /// @@ -2779,8 +2746,6 @@ pub trait Iterator { /// from the beginning. After iterating again, it will start at the /// beginning again. And again. And again. Forever. /// - /// [`None`]: ../../std/option/enum.Option.html#variant.None - /// /// # Examples /// /// Basic usage: @@ -3233,7 +3198,7 @@ pub trait Iterator { /// assert!(![0.0, 1.0, f32::NAN].iter().is_sorted_by(|a, b| a.partial_cmp(b))); /// ``` /// - /// [`is_sorted`]: trait.Iterator.html#method.is_sorted + /// [`is_sorted`]: #method.is_sorted #[unstable(feature = "is_sorted", reason = "new API", issue = "53485")] fn is_sorted_by(mut self, mut compare: F) -> bool where @@ -3262,7 +3227,7 @@ pub trait Iterator { /// the elements, as determined by `f`. Apart from that, it's equivalent to [`is_sorted`]; see /// its documentation for more information. /// - /// [`is_sorted`]: trait.Iterator.html#method.is_sorted + /// [`is_sorted`]: #method.is_sorted /// /// # Examples /// From 53a1d6f12fcef8e70fd8e687ebe05fa68e0c3858 Mon Sep 17 00:00:00 2001 From: Lzu Tao Date: Mon, 13 Jul 2020 15:58:57 +0000 Subject: [PATCH 2/8] Intra doc for iter marker traits --- src/libcore/iter/traits/marker.rs | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/src/libcore/iter/traits/marker.rs b/src/libcore/iter/traits/marker.rs index a9ba3908c3898..3c893c039923e 100644 --- a/src/libcore/iter/traits/marker.rs +++ b/src/libcore/iter/traits/marker.rs @@ -9,9 +9,8 @@ /// on the iterator. If the iterator is already fused, the additional [`Fuse`] /// wrapper will be a no-op with no performance penalty. /// -/// [`None`]: ../../std/option/enum.Option.html#variant.None -/// [`Iterator::fuse`]: ../../std/iter/trait.Iterator.html#method.fuse -/// [`Fuse`]: ../../std/iter/struct.Fuse.html +/// [`Iterator::fuse`]: crate::iter::Iterator::fuse +/// [`Fuse`]: crate::iter::Fuse #[stable(feature = "fused", since = "1.26.0")] #[rustc_unsafe_specialization_marker] pub trait FusedIterator: Iterator {} @@ -35,9 +34,8 @@ impl FusedIterator for &mut I {} /// This trait must only be implemented when the contract is upheld. /// Consumers of this trait must inspect [`.size_hint`]’s upper bound. /// -/// [`None`]: ../../std/option/enum.Option.html#variant.None -/// [`usize::MAX`]: ../../std/usize/constant.MAX.html -/// [`.size_hint`]: ../../std/iter/trait.Iterator.html#method.size_hint +/// [`usize::MAX`]: crate::usize::MAX +/// [`.size_hint`]: crate::iter::Iterator::size_hint #[unstable(feature = "trusted_len", issue = "37572")] #[rustc_unsafe_specialization_marker] pub unsafe trait TrustedLen: Iterator {} From 69f43ddbbede1f881299d989f62793c78685ab56 Mon Sep 17 00:00:00 2001 From: Lzu Tao Date: Mon, 13 Jul 2020 16:01:58 +0000 Subject: [PATCH 3/8] Intra-doc for DoubleEndIterator --- src/libcore/iter/traits/double_ended.rs | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/src/libcore/iter/traits/double_ended.rs b/src/libcore/iter/traits/double_ended.rs index f6329c6c593ed..851a1e49a493b 100644 --- a/src/libcore/iter/traits/double_ended.rs +++ b/src/libcore/iter/traits/double_ended.rs @@ -106,8 +106,7 @@ pub trait DoubleEndedIterator: Iterator { /// `nth_back()` will return [`None`] if `n` is greater than or equal to the length of the /// iterator. /// - /// [`None`]: ../../std/option/enum.Option.html#variant.None - /// [`nth`]: ../../std/iter/trait.Iterator.html#method.nth + /// [`nth`]: crate::iter::Iterator::nth /// /// # Examples /// @@ -274,8 +273,7 @@ pub trait DoubleEndedIterator: Iterator { /// argument is a double reference. You can see this effect in the /// examples below, with `&&x`. /// - /// [`Some(element)`]: ../../std/option/enum.Option.html#variant.Some - /// [`None`]: ../../std/option/enum.Option.html#variant.None + /// [`Some(element)`]: Some /// /// # Examples /// From a7f067a2a455dcd0d092c182d12b03dd2a8a93b3 Mon Sep 17 00:00:00 2001 From: Lzu Tao Date: Mon, 13 Jul 2020 16:05:32 +0000 Subject: [PATCH 4/8] Intra-doc for iter Sum and Product traits --- src/libcore/iter/traits/accum.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/libcore/iter/traits/accum.rs b/src/libcore/iter/traits/accum.rs index 55f30794af652..494c75174ff83 100644 --- a/src/libcore/iter/traits/accum.rs +++ b/src/libcore/iter/traits/accum.rs @@ -9,9 +9,9 @@ use crate::ops::{Add, Mul}; /// [`FromIterator`] this trait should rarely be called directly and instead /// interacted with through [`Iterator::sum`]. /// -/// [`sum`]: ../../std/iter/trait.Sum.html#tymethod.sum -/// [`FromIterator`]: ../../std/iter/trait.FromIterator.html -/// [`Iterator::sum`]: ../../std/iter/trait.Iterator.html#method.sum +/// [`sum`]: #tymethod.sum +/// [`FromIterator`]: crate::iter::FromIterator +/// [`Iterator::sum`]: crate::iter::Iterator::sum #[stable(feature = "iter_arith_traits", since = "1.12.0")] pub trait Sum: Sized { /// Method which takes an iterator and generates `Self` from the elements by @@ -28,9 +28,9 @@ pub trait Sum: Sized { /// [`FromIterator`] this trait should rarely be called directly and instead /// interacted with through [`Iterator::product`]. /// -/// [`product`]: ../../std/iter/trait.Product.html#tymethod.product -/// [`FromIterator`]: ../../std/iter/trait.FromIterator.html -/// [`Iterator::product`]: ../../std/iter/trait.Iterator.html#method.product +/// [`product`]: #tymethod.product +/// [`FromIterator`]: crate::iter::FromIterator +/// [`Iterator::product`]: crate::iter::Iterator::product #[stable(feature = "iter_arith_traits", since = "1.12.0")] pub trait Product: Sized { /// Method which takes an iterator and generates `Self` from the elements by From 3fb3c0c0bdbe05541c824c84f4755e1eaf4ed08b Mon Sep 17 00:00:00 2001 From: Lzu Tao Date: Mon, 13 Jul 2020 16:07:57 +0000 Subject: [PATCH 5/8] Remove unneeded link for Option --- src/libcore/iter/mod.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/src/libcore/iter/mod.rs b/src/libcore/iter/mod.rs index 080b70c6368b2..d10f074259cb2 100644 --- a/src/libcore/iter/mod.rs +++ b/src/libcore/iter/mod.rs @@ -55,7 +55,6 @@ //! //! [`Iterator`]: trait.Iterator.html //! [`next`]: trait.Iterator.html#tymethod.next -//! [`Option`]: ../../std/option/enum.Option.html //! [`TryIter`]: ../../std/sync/mpsc/struct.TryIter.html //! //! # The three forms of iteration From 1a90ba73fb950961385b8e011b7472c681019647 Mon Sep 17 00:00:00 2001 From: Lzu Tao Date: Tue, 14 Jul 2020 11:35:22 +0000 Subject: [PATCH 6/8] Link Some(item) --- src/libcore/iter/mod.rs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/libcore/iter/mod.rs b/src/libcore/iter/mod.rs index d10f074259cb2..3941a4c970036 100644 --- a/src/libcore/iter/mod.rs +++ b/src/libcore/iter/mod.rs @@ -39,11 +39,11 @@ //! ``` //! //! An iterator has a method, [`next`], which when called, returns an -//! [`Option`]``. [`next`] will return `Some(Item)` as long as there +//! [`Option`]``. [`next`] will return [`Some(Item)`] as long as there //! are elements, and once they've all been exhausted, will return `None` to //! indicate that iteration is finished. Individual iterators may choose to //! resume iteration, and so calling [`next`] again may or may not eventually -//! start returning `Some(Item)` again at some point (for example, see [`TryIter`]). +//! start returning [`Some(Item)`] again at some point (for example, see [`TryIter`]). //! //! [`Iterator`]'s full definition includes a number of other methods as well, //! but they are default methods, built on top of [`next`], and so you get @@ -53,6 +53,7 @@ //! more complex forms of processing. See the [Adapters](#adapters) section //! below for more details. //! +//! [`Some(Item)`]: Some //! [`Iterator`]: trait.Iterator.html //! [`next`]: trait.Iterator.html#tymethod.next //! [`TryIter`]: ../../std/sync/mpsc/struct.TryIter.html From 67c1e896575ab0afca53edaefd731c13451dfad9 Mon Sep 17 00:00:00 2001 From: Lzu Tao Date: Tue, 14 Jul 2020 11:35:56 +0000 Subject: [PATCH 7/8] Remove code span for impl Because the old one is harder to read and confuse typing checkers. --- src/libcore/iter/mod.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/libcore/iter/mod.rs b/src/libcore/iter/mod.rs index 3941a4c970036..9b528cdbe30c4 100644 --- a/src/libcore/iter/mod.rs +++ b/src/libcore/iter/mod.rs @@ -72,9 +72,9 @@ //! # Implementing Iterator //! //! Creating an iterator of your own involves two steps: creating a `struct` to -//! hold the iterator's state, and then `impl`ementing [`Iterator`] for that -//! `struct`. This is why there are so many `struct`s in this module: there is -//! one for each iterator and iterator adapter. +//! hold the iterator's state, and then implementing [`Iterator`] for that `struct`. +//! This is why there are so many `struct`s in this module: there is one for +//! each iterator and iterator adapter. //! //! Let's make an iterator named `Counter` which counts from `1` to `5`: //! From 5ffdd7c5651508e4af85261a6cebdee43650ce1a Mon Sep 17 00:00:00 2001 From: Lzu Tao Date: Fri, 17 Jul 2020 13:25:06 +0000 Subject: [PATCH 8/8] Deny intra_doc_link_resolution_failure in libcore --- src/libcore/lib.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs index 96436bb253df0..0bf7a55b65603 100644 --- a/src/libcore/lib.rs +++ b/src/libcore/lib.rs @@ -150,6 +150,7 @@ #![feature(slice_ptr_get)] #![feature(no_niche)] // rust-lang/rust#68303 #![feature(unsafe_block_in_unsafe_fn)] +#![deny(intra_doc_link_resolution_failure)] #![deny(unsafe_op_in_unsafe_fn)] #[prelude_import]