Removed all intra-doc-links from the needle docs.

They are not resolving (perhaps due to re-export) and causing CI failure.

Author: kennytm

src/libcore/needle/ext.rs

@@ -315,10 +315,10 @@ where
 
 generate_pattern_iterators! {
     forward:
-        /// Created with the function [`matches`].
+        /// Created with the function [`matches`](fn.matches.html).
         struct Matches;
     reverse:
-        /// Created with the function [`rmatches`].
+        /// Created with the function [`rmatches`](fn.rmatches.html).
         struct RMatches;
     stability:
     internal:
@@ -412,10 +412,10 @@ where
 
 generate_pattern_iterators! {
     forward:
-        /// Created with the function [`match_indices`].
+        /// Created with the function [`match_indices`](fn.match_indices.html).
         struct MatchIndices;
     reverse:
-        /// Created with the function [`rmatch_indices`].
+        /// Created with the function [`rmatch_indices`](fn.rmatch_indices.html).
         struct RMatchIndices;
     stability:
     internal:
@@ -530,10 +530,10 @@ where
 
 generate_pattern_iterators! {
     forward:
-        /// Created with the function [`match_ranges`].
+        /// Created with the function [`match_ranges`](fn.match_ranges.html).
         struct MatchRanges;
     reverse:
-        /// Created with the function [`rmatch_ranges`].
+        /// Created with the function [`rmatch_ranges`](fn.rmatch_ranges.html).
         struct RMatchRanges;
     stability:
     internal:
@@ -685,10 +685,10 @@ where
 
 generate_pattern_iterators! {
     forward:
-        /// Created with the function [`split`].
+        /// Created with the function [`split`](fn.split.html).
         struct Split;
     reverse:
-        /// Created with the function [`rsplit`].
+        /// Created with the function [`rsplit`](fn.rsplit.html).
         struct RSplit;
     stability:
     internal:
@@ -698,10 +698,10 @@ generate_pattern_iterators! {
 
 generate_pattern_iterators! {
     forward:
-        /// Created with the function [`split_terminator`].
+        /// Created with the function [`split_terminator`](fn.split_terminator.html).
         struct SplitTerminator;
     reverse:
-        /// Created with the function [`rsplit_terminator`].
+        /// Created with the function [`rsplit_terminator`](fn.rsplit_terminator.html).
         struct RSplitTerminator;
     stability:
     internal:
@@ -743,7 +743,7 @@ where
 
 /// An iterator over slices of the haystack, separated by parts matched by the needle.
 ///
-/// Equivalent to [`split`], except that the trailing slice is skipped if empty.
+/// Equivalent to [`split`](fn.split.html), except that the trailing slice is skipped if empty.
 ///
 /// This method can be used for haystack data that is *terminated*,
 /// rather than *separated* by a needle.
@@ -764,7 +764,7 @@ where
 /// An iterator over slices of the haystack, separated by parts matched by the needle
 /// and yielded in reverse order.
 ///
-/// Equivalent to [`rsplit`], except that the trailing slice is skipped if empty.
+/// Equivalent to [`rsplit`](fn.rsplit.html), except that the trailing slice is skipped if empty.
 ///
 /// This method can be used for haystack data that is *terminated*,
 /// rather than *separated* by a needle.
@@ -868,10 +868,10 @@ where
 
 generate_pattern_iterators! {
     forward:
-        /// Created with the function [`splitn`].
+        /// Created with the function [`splitn`](fn.splitn.html).
         struct SplitN;
     reverse:
-        /// Created with the function [`rsplitn`].
+        /// Created with the function [`rsplitn`](fn.rsplitn.html).
         struct RSplitN;
     stability:
     internal:

src/libcore/needle/haystack.rs

@@ -3,10 +3,10 @@ use ops::{Deref, Range};
 
 /// Borrowed `Haystack`.
 ///
-/// Every [`Haystack`] type can be borrowed as references to `Hay` types. This
-/// allows multiple similar types to share the same implementation (e.g. the
-/// haystacks `&[T]` and `&mut [T]` both have the same corresponding hay type
-/// `[T]`).
+/// Every [`Haystack`](trait.Haystack.html) type can be borrowed as references
+/// to `Hay` types. This allows multiple similar types to share the same
+/// implementation (e.g. the haystacks `&[T]` and `&mut [T]` both have the same
+/// corresponding hay type `[T]`).
 ///
 /// In the other words, a `Haystack` is a generalized reference to `Hay`.
 /// `Hay`s are typically implemented on unsized slice types like `str` and `[T]`.
@@ -141,9 +141,9 @@ pub unsafe trait Hay {
 ///
 /// A `Haystack` is implemented for reference and collection types such as
 /// `&str`, `&mut [T]` and `Vec<T>`. Every haystack can be borrowed as an
-/// underlying representation called a [`Hay`]. Multiple haystacks may share the
-/// same hay type, and thus share the same implementation of string search
-/// algorithms.
+/// underlying representation called a [`Hay`](trait.Hay.html).
+/// Multiple haystacks may share the same hay type, and thus share the same
+/// implementation of string search algorithms.
 ///
 /// In the other words, a `Haystack` is a generalized reference to `Hay`.
 ///
@@ -212,8 +212,9 @@ pub unsafe trait Haystack: Deref + Sized where Self::Target: Hay {
     /// (original.start + parent.start)..(original.start + parent.end)
     /// ```
     ///
-    /// If this haystack is a [`SharedHaystack`], this method should never be
-    /// called, and calling it would cause an unreachable panic.
+    /// If this haystack is a [`SharedHaystack`](trait.SharedHaystack.html),
+    /// this method should never be called, and calling it would cause an
+    /// unreachable panic.
     ///
     /// # Safety
     ///
@@ -257,7 +258,8 @@ pub unsafe trait Haystack: Deref + Sized where Self::Target: Hay {
     ) -> Range<<Self::Target as Hay>::Index>;
 }
 
-/// A [`Haystack`] which can be shared and cheaply cloned (e.g. `&H`, `Rc<H>`).
+/// A [`Haystack`](trait.Haystack.html) which can be shared and cheaply cloned
+/// (e.g. `&H`, `Rc<H>`).
 ///
 /// If a haystack implements this marker trait, during internal operations the
 /// original haystack will be retained in full and cloned, rather than being

src/libcore/needle/mod.rs

@@ -4,6 +4,9 @@
 //!
 //! This module provides traits to facilitate searching [`Needle`] in a [`Haystack`].
 //!
+//! [`Needle`]: trait.Needle.html
+//! [`Haystack`]: trait.Haystack.html
+//!
 //! Haystacks
 //! =========
 //!

src/libcore/needle/needle.rs

@@ -2,7 +2,8 @@ use super::haystack::{Haystack, Hay, Span};
 
 use ops::Range;
 
-/// A searcher, for searching a [`Needle`] from a [`Hay`].
+/// A searcher, for searching a [`Needle`](trait.Needle.html) from a
+/// [`Hay`](trait.Hay.html).
 ///
 /// This trait provides methods for searching for non-overlapping matches of a
 /// needle starting from the front (left) of a hay.
@@ -90,23 +91,22 @@ pub unsafe trait Searcher<A: Hay + ?Sized> {
     ///
     /// This method is used to support the following standard algorithms:
     ///
-    /// * [`matches`](std::needle::ext::matches)
-    /// * [`contains`](std::needle::ext::contains)
-    /// * [`match_indices`](std::needle::ext::match_indices)
-    /// * [`find`](std::needle::ext::find)
-    /// * [`match_ranges`](std::needle::ext::match_ranges)
-    /// * [`find_range`](std::needle::ext::find_range)
-    /// * [`split`](std::needle::ext::split)
-    /// * [`split_terminator`](std::needle::ext::split_terminator)
-    /// * [`splitn`](std::needle::ext::splitn)
-    /// * [`replace_with`](std::needle::ext::replace_with)
-    /// * [`replacen_with`](std::needle::ext::replacen_with)
+    /// * [`matches`](ext/fn.matches.html)
+    /// * [`contains`](ext/fn.contains.html)
+    /// * [`match_indices`](ext/fn.match_indices.html)
+    /// * [`find`](ext/fn.find.html)
+    /// * [`match_ranges`](ext/fn.match_ranges.html)
+    /// * [`find_range`](ext/fn.find_range.html)
+    /// * [`split`](ext/fn.split.html)
+    /// * [`split_terminator`](ext/fn.split_terminator.html)
+    /// * [`splitn`](ext/fn.splitn.html)
+    /// * [`replace_with`](ext/fn.replace_with.html)
+    /// * [`replacen_with`](ext/fn.replacen_with.html)
     ///
     /// The hay and the restricted range for searching can be recovered by
-    /// calling `span`[`.into_parts()`](Span::into_parts). The range returned
-    /// by this method
-    /// should be relative to the hay and must be contained within the
-    /// restricted range from the span.
+    /// calling `span`[`.into_parts()`](struct.Span.html#method.into_parts).
+    /// The range returned by this method should be relative to the hay and
+    /// must be contained within the restricted range from the span.
     ///
     /// If the needle is not found, this method should return `None`.
     ///
@@ -146,13 +146,13 @@ pub unsafe trait Searcher<A: Hay + ?Sized> {
     fn search(&mut self, span: Span<&A>) -> Option<Range<A::Index>>;
 }
 
-/// A consumer, for searching a [`Needle`] from a [`Hay`] anchored at the
-/// beginnning.
+/// A consumer, for searching a [`Needle`](trait.Needle.html) from a
+/// [`Hay`](trait.Hay.html) anchored at the beginnning.
 ///
 /// This trait provides methods for matching a needle anchored at the beginning
 /// of a hay.
 ///
-/// See documentation of [`Searcher`] for an example.
+/// See documentation of [`Searcher`](trait.Searcher.html) for an example.
 ///
 /// # Safety
 ///
@@ -163,13 +163,13 @@ pub unsafe trait Consumer<A: Hay + ?Sized> {
     /// Checks if the needle can be found at the beginning of the span.
     ///
     /// This method is used to implement the standard algorithm
-    /// [`starts_with()`](std::needle::ext::starts_with) as well as providing the default
-    /// implementation for [`.trim_start()`](Consumer::trim_start).
+    /// [`starts_with()`](ext/fn.starts_with.html) as well as providing
+    /// the default implementation for [`.trim_start()`](#method.trim_start).
     ///
     /// The hay and the restricted range for searching can be recovered by
-    /// calling `span`[`.into_parts()`](Span::into_parts). If a needle can be
-    /// found starting at `range.start`, this method should return the end index
-    /// of the needle relative to the hay.
+    /// calling `span`[`.into_parts()`](struct.Span.html#method.into_parts).
+    /// If a needle can be found starting at `range.start`, this method should
+    /// return the end index of the needle relative to the hay.
     ///
     /// If the needle cannot be found at the beginning of the span, this method
     /// should return `None`.
@@ -203,12 +203,12 @@ pub unsafe trait Consumer<A: Hay + ?Sized> {
     /// Repeatedly removes prefixes of the hay which matches the needle.
     ///
     /// This method is used to implement the standard algorithm
-    /// [`trim_start()`](std::needle::ext::trim_start).
+    /// [`trim_start()`](ext/fn.trim_start.html).
     ///
     /// Returns the start index of the slice after all prefixes are removed.
     ///
     /// A fast generic implementation in terms of
-    /// [`.consume()`](Consumer::consume) is provided by default. Nevertheless,
+    /// [`.consume()`](#method.consume) is provided by default. Nevertheless,
     /// many needles allow a higher-performance specialization.
     ///
     /// # Examples
@@ -254,19 +254,19 @@ pub unsafe trait ReverseSearcher<A: Hay + ?Sized>: Searcher<A> {
     ///
     /// This method is used to support the following standard algorithms:
     ///
-    /// * [`rmatches`](std::needle::ext::rmatches)
-    /// * [`rmatch_indices`](std::needle::ext::rmatch_indices)
-    /// * [`rfind`](std::needle::ext::find)
-    /// * [`rmatch_ranges`](std::needle::ext::rmatch_ranges)
-    /// * [`rfind_range`](std::needle::ext::rfind_range)
-    /// * [`rsplit`](std::needle::ext::rsplit)
-    /// * [`rsplit_terminator`](std::needle::ext::rsplit_terminator)
-    /// * [`rsplitn`](std::needle::ext::rsplitn)
+    /// * [`rmatches`](ext/fn.rmatches.html)
+    /// * [`rmatch_indices`](ext/fn.rmatch_indices.html)
+    /// * [`rfind`](ext/fn.find.html)
+    /// * [`rmatch_ranges`](ext/fn.rmatch_ranges.html)
+    /// * [`rfind_range`](ext/fn.rfind_range.html)
+    /// * [`rsplit`](ext/fn.rsplit.html)
+    /// * [`rsplit_terminator`](ext/fn.rsplit_terminator.html)
+    /// * [`rsplitn`](ext/fn.rsplitn.html)
     ///
     /// The hay and the restricted range for searching can be recovered by
-    /// calling `span`[`.into_parts()`](Span::into_parts). The returned range
-    /// should be relative to the hay and must be contained within the
-    /// restricted range from the span.
+    /// calling `span`[`.into_parts()`](struct.Span.html#method.into_parts).
+    /// The returned range should be relative to the hay and must be contained
+    /// within the restricted range from the span.
     ///
     /// If the needle is not found, this method should return `None`.
     ///
@@ -314,13 +314,13 @@ pub unsafe trait ReverseConsumer<A: Hay + ?Sized>: Consumer<A> {
     /// Checks if the needle can be found at the end of the span.
     ///
     /// This method is used to implement the standard algorithm
-    /// [`ends_with()`](std::needle::ext::ends_with) as well as providing the default
-    /// implementation for [`.trim_end()`](ReverseConsumer::trim_end).
+    /// [`ends_with()`](ext/fn.ends_with.html) as well as providing the default
+    /// implementation for [`.trim_end()`](#method.trim_end).
     ///
     /// The hay and the restricted range for searching can be recovered by
-    /// calling `span`[`.into_parts()`](Span::into_parts). If a needle can be
-    /// found ending at `range.end`, this method should return the start index
-    /// of the needle relative to the hay.
+    /// calling `span`[`.into_parts()`](struct.Span.html#method.into_parts).
+    /// If a needle can be found ending at `range.end`, this method should
+    /// return the start index of the needle relative to the hay.
     ///
     /// If the needle cannot be found at the end of the span, this method
     /// should return `None`.
@@ -354,10 +354,10 @@ pub unsafe trait ReverseConsumer<A: Hay + ?Sized>: Consumer<A> {
     /// Repeatedly removes suffixes of the hay which matches the needle.
     ///
     /// This method is used to implement the standard algorithm
-    /// [`trim_end()`](std::needle::ext::trim_end).
+    /// [`trim_end()`](ext/fn.trim_end.html).
     ///
     /// A fast generic implementation in terms of
-    /// [`.rconsume()`](ReverseConsumer::rconsume) is provided by default.
+    /// [`.rconsume()`](#method.rconsume) is provided by default.
     /// Nevertheless, many needles allow a higher-performance specialization.
     ///
     /// # Examples
@@ -391,20 +391,20 @@ pub unsafe trait ReverseConsumer<A: Hay + ?Sized>: Consumer<A> {
 /// A searcher which can be searched from both end with consistent results.
 ///
 /// Implementing this marker trait enables the following standard algorithms to
-/// return [`DoubleEndedIterator`](std::iter::DoubleEndedIterator)s:
-///
-/// * [`matches`](std::needle::ext::matches) /
-///     [`rmatches`](std::needle::ext::rmatches)
-/// * [`match_indices`](std::needle::ext::match_indices) /
-///     [`rmatch_indices`](std::needle::ext::rmatch_indices)
-/// * [`match_ranges`](std::needle::ext::match_ranges) /
-///     [`rmatch_ranges`](std::needle::ext::rmatch_ranges)
-/// * [`split`](std::needle::ext::split) /
-///     [`rsplit`](std::needle::ext::rsplit)
-/// * [`split_terminator`](std::needle::ext::split_terminator) /
-///     [`rsplit_terminator`](std::needle::ext::rsplit_terminator)
-/// * [`splitn`](std::needle::ext::splitn) /
-///     [`rsplitn`](std::needle::ext::rsplitn)
+/// return [`DoubleEndedIterator`](../iter/trait.DoubleEndedIterator.html)s:
+///
+/// * [`matches`](ext/fn.matches.html) /
+///     [`rmatches`](ext/fn.rmatches.html)
+/// * [`match_indices`](ext/fn.match_indices.html) /
+///     [`rmatch_indices`](ext/fn.rmatch_indices.html)`
+/// * [`match_ranges`](ext/fn.match_ranges.html) /
+///     [`rmatch_ranges`](ext/fn.rmatch_ranges.html)
+/// * [`split`](ext/fn.split.html) /
+///     [`rsplit`](ext/fn.rsplit.html)
+/// * [`split_terminator`](ext/fn.split_terminator.html) /
+///     [`rsplit_terminator`](ext/fn.rsplit_terminator.html)
+/// * [`splitn`](ext/fn.splitn.html) /
+///     [`rsplitn`](ext/fn.rsplitn.html)
 ///
 /// # Examples
 ///
@@ -442,10 +442,10 @@ pub unsafe trait DoubleEndedSearcher<A: Hay + ?Sized>: ReverseSearcher<A> {}
 ///
 /// It is used to support the following standard algorithm:
 ///
-/// * [`trim`](std::needle::ext::trim)
+/// * [`trim`](ext/fn.trim.html)
 ///
 /// The `trim` function is implemented by calling
-/// [`trim_start`](std::needle::ext::trim_start) and [`trim_end`](std::needle::ext::trim_end)
+/// [`trim_start`](ext/fn.trim_start.html) and [`trim_end`](ext/fn.trim_end.html)
 /// together. This trait encodes the fact that we can call these two functions in any order.
 ///
 /// # Examples
@@ -477,11 +477,11 @@ pub unsafe trait DoubleEndedConsumer<A: Hay + ?Sized>: ReverseConsumer<A> {}
 
 /// A needle, a type which can be converted into a searcher.
 ///
-/// When using search algorithms like [`split()`](std::needle::ext::split), users will
+/// When using search algorithms like [`split()`](ext/fn.split.html), users will
 /// search with a `Needle` e.g. a `&str`. A needle is usually stateless,
 /// however for efficient searching, we often need some preprocessing and
 /// maintain a mutable state. The preprocessed structure is called the
-/// [`Searcher`] of this needle.
+/// [`Searcher`](trait.Searcher.html) of this needle.
 ///
 /// The relationship between `Searcher` and `Needle` is similar to `Iterator`
 /// and `IntoIterator`.

src/libcore/str/mod.rs

@@ -2888,7 +2888,7 @@ impl str {
     /// Equivalent to [`rsplit`], except that the trailing substring is
     /// skipped if empty.
     ///
-    /// [`split`]: #method.split
+    /// [`rsplit`]: #method.rsplit
     ///
     /// This method can be used for string data that is _terminated_,
     /// rather than _separated_ by a pattern.