Re-link documentation where possible in alloc::io

Items in the prelude can't have hardcoded links, as they are either correct in the prelude or in their original location, not both.

Author: bushrat011899

library/alloc/src/io/buf_read.rs

@@ -4,7 +4,7 @@ use crate::io::{ErrorKind, Lines, Read, Result, Split, append_to_string, lines,
 use crate::string::String;
 use crate::vec::Vec;
 
-/// A `BufRead` is a type of `Read`er which has an internal buffer, allowing it
+/// A `BufRead` is a type of [`Read`]er which has an internal buffer, allowing it
 /// to perform extra ways of reading.
 ///
 /// For example, reading line-by-line is inefficient without using a buffer, so
@@ -55,7 +55,7 @@ use crate::vec::Vec;
 #[stable(feature = "rust1", since = "1.0.0")]
 #[cfg_attr(not(test), rustc_diagnostic_item = "IoBufRead")]
 pub trait BufRead: Read {
-    /// Returns the contents of the internal buffer, filling it with more data, via `Read` methods, if empty.
+    /// Returns the contents of the internal buffer, filling it with more data, via [`Read`] methods, if empty.
     ///
     /// This is a lower-level method and is meant to be used together with [`consume`],
     /// which can be used to mark bytes that should not be returned by subsequent calls to `read`.
@@ -66,7 +66,7 @@ pub trait BufRead: Read {
     ///
     /// # Errors
     ///
-    /// This function will return an I/O error if a `Read` method was called, but returned an error.
+    /// This function will return an I/O error if a [`Read`] method was called, but returned an error.
     ///
     /// # Examples
     ///
@@ -96,7 +96,7 @@ pub trait BufRead: Read {
     /// Subsequent calls to `read` only return bytes that have not been marked as read.
     ///
     /// This is a lower-level method and is meant to be used together with [`fill_buf`],
-    /// which can be used to fill the internal buffer via `Read` methods.
+    /// which can be used to fill the internal buffer via [`Read`] methods.
     ///
     /// It is a logic error if `amount` exceeds the number of unread bytes in the internal buffer, which is returned by [`fill_buf`].
     ///
@@ -120,7 +120,7 @@ pub trait BufRead: Read {
     ///
     /// # Errors
     ///
-    /// This function will return an I/O error if a `Read` method was called, but returned an error.
+    /// This function will return an I/O error if a [`Read`] method was called, but returned an error.
     ///
     /// Examples
     ///
@@ -274,7 +274,7 @@ pub trait BufRead: Read {
     }
 
     /// Reads all bytes until a newline (the `0xA` byte) is reached, and append
-    /// them to the provided `String` buffer.
+    /// them to the provided [`String`] buffer.
     ///
     /// Previous content of the buffer will be preserved. To avoid appending to
     /// the buffer, you need to [`clear`] it first.

library/alloc/src/io/buffered/bufreader.rs

@@ -19,6 +19,8 @@ use crate::vec::Vec;
 /// results in a system call. A `BufReader<R>` performs large, infrequent reads on
 /// the underlying [`Read`] and maintains an in-memory buffer of the results.
 ///
+/// [`TcpStream`]: ../../std/net/struct.TcpStream.html
+///
 /// `BufReader<R>` can improve the speed of programs that make *small* and
 /// *repeated* read calls to the same file or network socket. It does not
 /// help when reading very large amounts at once, or reading just one or a few

library/alloc/src/io/buffered/bufwriter.rs

@@ -28,7 +28,9 @@ use crate::vec::Vec;
 ///
 /// # Examples
 ///
-/// Let's write the numbers one through ten to a `TcpStream`:
+/// Let's write the numbers one through ten to a [`TcpStream`]:
+///
+/// [`TcpStream`]: ../../std/net/struct.TcpStream.html
 ///
 /// ```no_run
 /// use std::io::prelude::*;

library/alloc/src/io/read.rs

@@ -22,8 +22,11 @@ use crate::vec::Vec;
 /// trait.
 ///
 /// Please note that each call to [`read()`] may involve a system call, and
-/// therefore, using something that implements `BufRead`, such as
-/// `BufReader`, will be more efficient.
+/// therefore, using something that implements [`BufRead`], such as
+/// [`BufReader`], will be more efficient.
+///
+/// [`BufRead`]: crate::io::BufRead
+/// [`BufReader`]: crate::io::BufReader
 ///
 /// Repeated calls to the reader use the same cursor, so for example
 /// calling `read_to_end` twice on a `File` will only return the file's
@@ -480,7 +483,9 @@ pub trait Read {
     ///
     /// The default implementation calls `read` for each byte,
     /// which can be very inefficient for data that's not in memory,
-    /// such as `File`. Consider using a `BufReader` in such cases.
+    /// such as `File`. Consider using a [`BufReader`] in such cases.
+    ///
+    /// [`BufReader`]: crate::io::BufReader
     ///
     /// # Examples
     ///

library/alloc/src/io/util.rs

@@ -440,9 +440,9 @@ pub const fn split<B>(buf: B, delim: u8) -> Split<B> {
     Split { buf, delim }
 }
 
-/// An iterator over the lines of an instance of `BufRead`.
+/// An iterator over the lines of an instance of [`BufRead`].
 ///
-/// This struct is generally created by calling [`lines`] on a `BufRead`.
+/// This struct is generally created by calling [`lines`] on a [`BufRead`].
 /// Please see the documentation of [`lines`] for more details.
 ///
 /// [`lines`]: BufRead::lines