std: update broken links in thread module

Author: joboet

library/std/src/thread/builder.rs

@@ -39,7 +39,7 @@ use crate::io;
 /// [`stack_size`]: Builder::stack_size
 /// [`name`]: Builder::name
 /// [`spawn`]: Builder::spawn
-/// [`thread::spawn`]: spawn
+/// [`thread::spawn`]: super::spawn
 /// [`io::Result`]: crate::io::Result
 /// [`unwrap`]: crate::result::Result::unwrap
 /// [naming-threads]: ./index.html#naming-threads
@@ -133,10 +133,12 @@ impl Builder {
         self
     }
 
-    /// Disables running and inheriting [spawn hooks](add_spawn_hook).
+    /// Disables running and inheriting [spawn hooks].
     ///
     /// Use this if the parent thread is in no way relevant for the child thread.
     /// For example, when lazily spawning threads for a thread pool.
+    ///
+    /// [spawn hooks]: super::add_spawn_hook
     #[unstable(feature = "thread_spawn_hook", issue = "132951")]
     pub fn no_hooks(mut self) -> Builder {
         self.no_hooks = true;
@@ -151,7 +153,7 @@ impl Builder {
     /// thread finishes). The join handle can be used to block on
     /// termination of the spawned thread, including recovering its panics.
     ///
-    /// For a more complete documentation see [`thread::spawn`][`spawn`].
+    /// For a more complete documentation see [`thread::spawn`].
     ///
     /// # Errors
     ///
@@ -178,6 +180,9 @@ impl Builder {
     ///
     /// handler.join().unwrap();
     /// ```
+    ///
+    /// [`thread::spawn`]: super::spawn
+    /// [`spawn`]: super::spawn
     #[stable(feature = "rust1", since = "1.0.0")]
     #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
     pub fn spawn<F, T>(self, f: F) -> io::Result<JoinHandle<T>>
@@ -199,7 +204,7 @@ impl Builder {
     ///
     /// This method is identical to [`thread::Builder::spawn`][`Builder::spawn`],
     /// except for the relaxed lifetime bounds, which render it unsafe.
-    /// For a more complete documentation see [`thread::spawn`][`spawn`].
+    /// For a more complete documentation see [`thread::spawn`].
     ///
     /// # Errors
     ///
@@ -221,7 +226,7 @@ impl Builder {
     /// data is dropped
     /// - use only types with `'static` lifetime bounds, i.e., those with no or only
     /// `'static` references (both [`thread::Builder::spawn`][`Builder::spawn`]
-    /// and [`thread::spawn`][`spawn`] enforce this property statically)
+    /// and [`thread::spawn`] enforce this property statically)
     ///
     /// # Examples
     ///
@@ -246,6 +251,8 @@ impl Builder {
     /// ```
     ///
     /// [`io::Result`]: crate::io::Result
+    /// [`thread::spawn`]: super::spawn
+    /// [`spawn`]: super::spawn
     #[stable(feature = "thread_spawn_unchecked", since = "1.82.0")]
     #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
     pub unsafe fn spawn_unchecked<F, T>(self, f: F) -> io::Result<JoinHandle<T>>

library/std/src/thread/functions.rs

@@ -517,7 +517,8 @@ impl Drop for PanicGuard {
 /// parked_thread.join().unwrap();
 /// ```
 ///
-/// [`unpark`]: Thread::unpark
+/// [`Thread`]: super::Thread
+/// [`unpark`]: super::Thread::unpark
 /// [`thread::park_timeout`]: park_timeout
 /// [release sequence]: https://en.cppreference.com/w/cpp/atomic/memory_order#Release_sequence
 #[stable(feature = "rust1", since = "1.0.0")]

library/std/src/thread/id.rs

@@ -24,7 +24,8 @@ use crate::sync::atomic::{Atomic, Ordering};
 /// assert!(thread::current().id() != other_thread_id);
 /// ```
 ///
-/// [`id`]: Thread::id
+/// [`Thread`]: super::Thread
+/// [`id`]: super::Thread::id
 #[stable(feature = "thread_id", since = "1.19.0")]
 #[derive(Eq, PartialEq, Clone, Copy, Hash, Debug)]
 pub struct ThreadId(NonZero<u64>);

library/std/src/thread/join_handle.rs

@@ -65,8 +65,8 @@ use crate::sys_common::{AsInner, IntoInner};
 /// thread::sleep(Duration::from_millis(1000));
 /// ```
 ///
-/// [`thread::Builder::spawn`]: Builder::spawn
-/// [`thread::spawn`]: spawn
+/// [`thread::Builder::spawn`]: super::Builder::spawn
+/// [`thread::spawn`]: super::spawn
 #[stable(feature = "rust1", since = "1.0.0")]
 #[cfg_attr(target_os = "teeos", must_use)]
 pub struct JoinHandle<T>(pub(super) JoinInner<'static, T>);
@@ -143,7 +143,7 @@ impl<T> JoinHandle<T> {
     /// type.
     ///
     /// [`catch_unwind`]: ../../std/panic/fn.catch_unwind.html
-    /// [`thread::spawn`]: spawn
+    /// [`thread::spawn`]: super::spawn
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn join(self) -> Result<T> {
         self.0.join()

library/std/src/thread/mod.rs

@@ -137,6 +137,7 @@
 //! Note that the stack size of the main thread is *not* determined by Rust.
 //!
 //! [channels]: crate::sync::mpsc
+//! [`Arc`]: crate::sync::Arc
 //! [`join`]: JoinHandle::join
 //! [`Result`]: crate::result::Result
 //! [`Ok`]: crate::result::Result::Ok

library/std/src/thread/thread.rs

@@ -65,9 +65,8 @@ impl Inner {
 /// Threads are represented via the `Thread` type, which you can get in one of
 /// two ways:
 ///
-/// * By spawning a new thread, e.g., using the [`thread::spawn`][`spawn`]
-///   function, and calling [`thread`][`JoinHandle::thread`] on the
-///   [`JoinHandle`].
+/// * By spawning a new thread, e.g., using the [`thread::spawn`]
+///   function, and calling [`thread`] on the [`JoinHandle`].
 /// * By requesting the current thread, using the [`thread::current`] function.
 ///
 /// The [`thread::current`] function is available even for threads not spawned
@@ -77,7 +76,12 @@ impl Inner {
 /// should instead use a function like `spawn` to create new threads, see the
 /// docs of [`Builder`] and [`spawn`] for more details.
 ///
-/// [`thread::current`]: current::current
+/// [`thread::spawn`]: super::spawn
+/// [`thread`]: super::JoinHandle::thread
+/// [`JoinHandle`]: super::JoinHandle
+/// [`thread::current`]: super::current::current
+/// [`Builder`]: super::Builder
+/// [`spawn`]: super::spawn
 pub struct Thread {
     // We use the System allocator such that creating or dropping this handle
     // does not interfere with a potential Global allocator using thread-local
@@ -111,6 +115,8 @@ impl Thread {
     ///
     /// # Safety
     /// May only be called from the thread to which this handle belongs.
+    ///
+    /// [`park`]: super::park
     pub(crate) unsafe fn park(&self) {
         unsafe { self.inner.as_ref().parker().park() }
     }
@@ -120,17 +126,19 @@ impl Thread {
     ///
     /// # Safety
     /// May only be called from the thread to which this handle belongs.
+    ///
+    /// [`park_timeout`]: super::park_timeout
     pub(crate) unsafe fn park_timeout(&self, dur: Duration) {
         unsafe { self.inner.as_ref().parker().park_timeout(dur) }
     }
 
     /// Atomically makes the handle's token available if it is not already.
     ///
     /// Every thread is equipped with some basic low-level blocking support, via
-    /// the [`park`][park] function and the `unpark()` method. These can be
-    /// used as a more CPU-efficient implementation of a spinlock.
+    /// the [`park`] function and the `unpark()` method. These can be used as a
+    /// more CPU-efficient implementation of a spinlock.
     ///
-    /// See the [park documentation][park] for more details.
+    /// See the [park documentation] for more details.
     ///
     /// # Examples
     ///
@@ -167,6 +175,9 @@ impl Thread {
     ///
     /// parked_thread.join().unwrap();
     /// ```
+    ///
+    /// [`park`]: super::park
+    /// [park documentation]: super::park
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn unpark(&self) {