Fix module references in blocking read-write lock implementation

2 files changed, 18 insertions, 18 deletions

diff --git a/embassy-sync/src/blocking_rwlock/mod.rs b/embassy-sync/src/blocking_rwlock/mod.rs
index a8fb7d6bc..88cd2164b 100644
--- a/embassy-sync/src/blocking_rwlock/mod.rs
+++ b/embassy-sync/src/blocking_rwlock/mod.rs
@@ -9,7 +9,7 @@ use self::raw::RawRwLock;
 
 /// Blocking read-write lock (not async)
 ///
-/// Provides a blocking read-write lock primitive backed by an implementation of [`raw_rwlock::RawRwLock`].
+/// Provides a blocking read-write lock primitive backed by an implementation of [`raw::RawRwLock`].
 ///
 /// Which implementation you select depends on the context in which you're using the read-write lock, and you can choose which kind
 /// of interior mutability fits your use case.
@@ -94,16 +94,16 @@ impl<R, T> RwLock<R, T> {
 /// # Safety
 ///
 /// This read-write lock is safe to share between different executors and interrupts.
-pub type CriticalSectionRwLock<T> = RwLock<raw_rwlock::CriticalSectionRawRwLock, T>;
+pub type CriticalSectionRwLock<T> = RwLock<raw::CriticalSectionRawRwLock, T>;
 
 /// A read-write lock that allows borrowing data in the context of a single executor.
 ///
 /// # Safety
 ///
 /// **This Read-Write Lock is only safe within a single executor.**
-pub type NoopRwLock<T> = RwLock<raw_rwlock::NoopRawRwLock, T>;
+pub type NoopRwLock<T> = RwLock<raw::NoopRawRwLock, T>;
 
-impl<T> RwLock<raw_rwlock::CriticalSectionRawRwLock, T> {
+impl<T> RwLock<raw::CriticalSectionRawRwLock, T> {
     /// Borrows the data for the duration of the critical section
     pub fn borrow<'cs>(&'cs self, _cs: critical_section::CriticalSection<'cs>) -> &'cs T {
         let ptr = self.data.get() as *const T;
@@ -111,7 +111,7 @@ impl<T> RwLock<raw_rwlock::CriticalSectionRawRwLock, T> {
     }
 }
 
-impl<T> RwLock<raw_rwlock::NoopRawRwLock, T> {
+impl<T> RwLock<raw::NoopRawRwLock, T> {
     /// Borrows the data
     #[allow(clippy::should_implement_trait)]
     pub fn borrow(&self) -> &T {
@@ -184,7 +184,7 @@ mod thread_mode_rwlock {
         /// This will panic if not currently running in thread mode.
         pub fn borrow(&self) -> &T {
             assert!(
-                raw_rwlock::in_thread_mode(),
+                raw::in_thread_mode(),
                 "ThreadModeRwLock can only be borrowed from thread mode."
             );
             unsafe { &*self.inner.get() }
@@ -197,7 +197,7 @@ mod thread_mode_rwlock {
         /// This will panic if not currently running in thread mode.
         pub fn borrow_mut(&self) -> &mut T {
             assert!(
-                raw_rwlock::in_thread_mode(),
+                raw::in_thread_mode(),
                 "ThreadModeRwLock can only be borrowed from thread mode."
             );
             unsafe { &mut *self.inner.get() }
@@ -211,7 +211,7 @@ mod thread_mode_rwlock {
             // T isn't, so without this check a user could create a ThreadModeRwLock in thread mode,
             // send it to interrupt context and drop it there, which would "send" a T even if T is not Send.
             assert!(
-                raw_rwlock::in_thread_mode(),
+                raw::in_thread_mode(),
                 "ThreadModeRwLock can only be dropped from thread mode."
             );
 
diff --git a/embassy-sync/src/rwlock.rs b/embassy-sync/src/rwlock.rs
index 365f6fda5..9fa61ee56 100644
--- a/embassy-sync/src/rwlock.rs
+++ b/embassy-sync/src/rwlock.rs
@@ -2,13 +2,13 @@
 //!
 //! This module provides a read-write lock that can be used to synchronize data between asynchronous tasks.
 use core::cell::{RefCell, UnsafeCell};
+use core::fmt;
 use core::future::{poll_fn, Future};
 use core::ops::{Deref, DerefMut};
 use core::task::Poll;
-use core::{fmt, mem};
 
-use crate::blocking_mutex::raw::RawRwLock;
-use crate::blocking_mutex::RwLock as BlockingRwLock;
+use crate::blocking_rwlock::raw::RawRwLock;
+use crate::blocking_rwlock::RwLock as BlockingRwLock;
 use crate::waitqueue::WakerRegistration;
 
 /// Error returned by [`RwLock::try_read_lock`] and [`RwLock::try_write_lock`]
@@ -77,7 +77,7 @@ where
     /// This will wait for the lock to be available if it's already locked for writing.
     pub fn read_lock(&self) -> impl Future<Output = RwLockReadGuard<'_, R, T>> {
         poll_fn(|cx| {
-            let ready = self.state.lock(|s| {
+            let ready = self.state.write_lock(|s| {
                 let mut s = s.borrow_mut();
                 if s.writer {
                     s.waker.register(cx.waker());
@@ -101,7 +101,7 @@ where
     /// This will wait for the lock to be available if it's already locked for reading or writing.
     pub fn write_lock(&self) -> impl Future<Output = RwLockWriteGuard<'_, R, T>> {
         poll_fn(|cx| {
-            let ready = self.state.lock(|s| {
+            let ready = self.state.write_lock(|s| {
                 let mut s = s.borrow_mut();
                 if s.readers > 0 || s.writer {
                     s.waker.register(cx.waker());
@@ -124,7 +124,7 @@ where
     ///
     /// If the lock is already locked for writing, this will return an error instead of waiting.
     pub fn try_read_lock(&self) -> Result<RwLockReadGuard<'_, R, T>, TryLockError> {
-        self.state.lock(|s| {
+        self.state.read_lock(|s| {
             let mut s = s.borrow_mut();
             if s.writer {
                 Err(TryLockError)
@@ -141,7 +141,7 @@ where
     ///
     /// If the lock is already locked for reading or writing, this will return an error instead of waiting.
     pub fn try_write_lock(&self) -> Result<RwLockWriteGuard<'_, R, T>, TryLockError> {
-        self.state.lock(|s| {
+        self.state.write_lock(|s| {
             let mut s = s.borrow_mut();
             if s.readers > 0 || s.writer {
                 Err(TryLockError)
@@ -229,7 +229,7 @@ where
     T: ?Sized,
 {
     fn drop(&mut self) {
-        self.rwlock.state.lock(|s| {
+        self.rwlock.state.write_lock(|s| {
             let mut s = unwrap!(s.try_borrow_mut());
             s.readers -= 1;
             if s.readers == 0 {
@@ -294,7 +294,7 @@ where
     T: ?Sized,
 {
     fn drop(&mut self) {
-        self.rwlock.state.lock(|s| {
+        self.rwlock.state.write_lock(|s| {
             let mut s = unwrap!(s.try_borrow_mut());
             s.writer = false;
             s.waker.wake();
@@ -349,7 +349,7 @@ where
 
 #[cfg(test)]
 mod tests {
-    use crate::blocking_mutex::raw_rwlock::NoopRawRwLock;
+    use crate::blocking_rwlock::raw::NoopRawRwLock;
     use crate::rwlock::{RwLock, RwLockReadGuard, RwLockWriteGuard};
 
     #[futures_test::test]