Fix broken links in docs

src/barrier.rs

@@ -96,8 +96,8 @@ impl Barrier {
     ///
     /// # Blocking
     ///
-    /// Rather than using asynchronous waiting, like the [`wait`] method, this method will
-    /// block the current thread until the wait is complete.
+    /// Rather than using asynchronous waiting, like the [`wait`][`Barrier::wait`] method,
+    /// this method will block the current thread until the wait is complete.
     ///
     /// This method should not be used in an asynchronous context. It is intended to be
     /// used in a way that a barrier can be used in both asynchronous and synchronous contexts.

src/mutex.rs

@@ -118,8 +118,8 @@ impl<T: ?Sized> Mutex<T> {
     ///
     /// # Blocking
     ///
-    /// Rather than using asynchronous waiting, like the [`lock`] method, this method will
-    /// block the current thread until the lock is acquired.
+    /// Rather than using asynchronous waiting, like the [`lock`][Mutex::lock] method,
+    /// this method will block the current thread until the lock is acquired.
     ///
     /// This method should not be used in an asynchronous context. It is intended to be
     /// used in a way that a mutex can be used in both asynchronous and synchronous contexts.
@@ -233,8 +233,8 @@ impl<T: ?Sized> Mutex<T> {
     ///
     /// # Blocking
     ///
-    /// Rather than using asynchronous waiting, like the [`lock_arc`] method, this method will
-    /// block the current thread until the lock is acquired.
+    /// Rather than using asynchronous waiting, like the [`lock_arc`][Mutex::lock_arc] method,
+    /// this method will block the current thread until the lock is acquired.
     ///
     /// This method should not be used in an asynchronous context. It is intended to be
     /// used in a way that a mutex can be used in both asynchronous and synchronous contexts.

src/rwlock.rs

@@ -216,8 +216,8 @@ impl<T: ?Sized> RwLock<T> {
     ///
     /// # Blocking
     ///
-    /// Rather than using asynchronous waiting, like the [`read`] method, this method will
-    /// block the current thread until the read lock is acquired.
+    /// Rather than using asynchronous waiting, like the [`read`][`RwLock::read`] method,
+    /// this method will block the current thread until the read lock is acquired.
     ///
     /// This method should not be used in an asynchronous context. It is intended to be
     /// used in a way that a lock can be used in both asynchronous and synchronous contexts.
@@ -320,8 +320,8 @@ impl<T: ?Sized> RwLock<T> {
     ///
     /// # Blocking
     ///
-    /// Rather than using asynchronous waiting, like the [`upgradable_read`] method, this method will
-    /// block the current thread until the read lock is acquired.
+    /// Rather than using asynchronous waiting, like the [`upgradable_read`][`RwLock::upgradable_read`]
+    /// method, this method will block the current thread until the read lock is acquired.
     ///
     /// This method should not be used in an asynchronous context. It is intended to be
     /// used in a way that a lock can be used in both asynchronous and synchronous contexts.

src/semaphore.rs

@@ -98,8 +98,8 @@ impl Semaphore {
     ///
     /// # Blocking
     ///
-    /// Rather than using asynchronous waiting, like the [`acquire`] method, this method will
-    /// block the current thread until the permit is acquired.
+    /// Rather than using asynchronous waiting, like the [`acquire`][Semaphore::acquire] method,
+    /// this method will block the current thread until the permit is acquired.
     ///
     /// This method should not be used in an asynchronous context. It is intended to be
     /// used in a way that a semaphore can be used in both asynchronous and synchronous contexts.