promote debug_assert to assert

Signed-off-by: Vincenzo Palazzo <[email protected]>

Author: vincenzopalazzo

library/std/src/alloc.rs

@@ -154,7 +154,7 @@ impl System {
         new_layout: Layout,
         zeroed: bool,
     ) -> Result<NonNull<[u8]>, AllocError> {
-        debug_assert!(
+        assert!(
             new_layout.size() >= old_layout.size(),
             "`new_layout.size()` must be greater than or equal to `old_layout.size()`"
         );
@@ -246,7 +246,7 @@ unsafe impl Allocator for System {
         old_layout: Layout,
         new_layout: Layout,
     ) -> Result<NonNull<[u8]>, AllocError> {
-        debug_assert!(
+        assert!(
             new_layout.size() <= old_layout.size(),
             "`new_layout.size()` must be smaller than or equal to `old_layout.size()`"
         );

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

@@ -376,7 +376,7 @@ impl<R: Read> BufRead for BufReader<R> {
         // Branch using `>=` instead of the more correct `==`
         // to tell the compiler that the pos..cap slice is always valid.
         if self.pos >= self.cap {
-            debug_assert!(self.pos == self.cap);
+            assert!(self.pos == self.cap, "unexpected end of buffer");
 
             let mut readbuf = ReadBuf::uninit(&mut self.buf);
 

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

@@ -428,7 +428,7 @@ impl<W: Write> BufWriter<W> {
     // i.e., that input buffer length is less than or equal to spare capacity.
     #[inline]
     unsafe fn write_to_buffer_unchecked(&mut self, buf: &[u8]) {
-        debug_assert!(buf.len() <= self.spare_capacity());
+        assert!(buf.len() <= self.spare_capacity(), "unexpected write operation");
         let old_len = self.buf.len();
         let buf_len = buf.len();
         let src = buf.as_ptr();
@@ -610,7 +610,7 @@ impl<W: Write> Write for BufWriter<W> {
             } else {
                 return Ok(0);
             };
-            debug_assert!(total_written != 0);
+            assert!(total_written != 0, "unexpected `total_written` value: {:?}", total_written);
             for buf in iter {
                 if buf.len() <= self.spare_capacity() {
                     // SAFETY: safe by above conditional.

library/std/src/io/cursor.rs

@@ -426,7 +426,7 @@ fn reserve_and_pad<A: Allocator>(
         // realise the `reserve` it does can be eliminated. So we do it manually
         // to eliminate that extra branch
         let spare = vec.spare_capacity_mut();
-        debug_assert!(spare.len() >= diff);
+        assert!(spare.len() >= diff, "unexpected allocated capacity");
         // Safety: we have allocated enough capacity for this.
         // And we are only writing, not reading
         unsafe {
@@ -444,7 +444,7 @@ unsafe fn vec_write_unchecked<A>(pos: usize, vec: &mut Vec<u8, A>, buf: &[u8]) -
 where
     A: Allocator,
 {
-    debug_assert!(vec.capacity() >= pos + buf.len());
+    assert!(vec.capacity() >= pos + buf.len(), "unexpected write out of bound");
     vec.as_mut_ptr().add(pos).copy_from(buf.as_ptr(), buf.len());
     pos + buf.len()
 }

library/std/src/path.rs

@@ -749,7 +749,7 @@ impl<'a> Components<'a> {
     // parse a component from the left, saying how many bytes to consume to
     // remove the component
     fn parse_next_component(&self) -> (usize, Option<Component<'a>>) {
-        debug_assert!(self.front == State::Body);
+        assert!(self.front == State::Body, "unexpected component during parsing: {:?}", self.front);
         let (extra, comp) = match self.path.iter().position(|b| self.is_sep_byte(*b)) {
             None => (0, self.path),
             Some(i) => (1, &self.path[..i]),
@@ -760,7 +760,7 @@ impl<'a> Components<'a> {
     // parse a component from the right, saying how many bytes to consume to
     // remove the component
     fn parse_next_component_back(&self) -> (usize, Option<Component<'a>>) {
-        debug_assert!(self.back == State::Body);
+        assert!(self.back == State::Body, "unexpected component during parsing: {:?}", self.back);
         let start = self.len_before_body();
         let (extra, comp) = match self.path[start..].iter().rposition(|b| self.is_sep_byte(*b)) {
             None => (0, &self.path[start..]),
@@ -893,7 +893,11 @@ impl<'a> Iterator for Components<'a> {
             match self.front {
                 State::Prefix if self.prefix_len() > 0 => {
                     self.front = State::StartDir;
-                    debug_assert!(self.prefix_len() <= self.path.len());
+                    assert!(
+                        self.prefix_len() <= self.path.len(),
+                        "unexpected prefix len: {:?}",
+                        self.prefix_len()
+                    );
                     let raw = &self.path[..self.prefix_len()];
                     self.path = &self.path[self.prefix_len()..];
                     return Some(Component::Prefix(PrefixComponent {
@@ -907,15 +911,15 @@ impl<'a> Iterator for Components<'a> {
                 State::StartDir => {
                     self.front = State::Body;
                     if self.has_physical_root {
-                        debug_assert!(!self.path.is_empty());
+                        assert!(!self.path.is_empty(), "unexpected path value");
                         self.path = &self.path[1..];
                         return Some(Component::RootDir);
                     } else if let Some(p) = self.prefix {
                         if p.has_implicit_root() && !p.is_verbatim() {
                             return Some(Component::RootDir);
                         }
                     } else if self.include_cur_dir() {
-                        debug_assert!(!self.path.is_empty());
+                        assert!(!self.path.is_empty(), "unexpected path value");
                         self.path = &self.path[1..];
                         return Some(Component::CurDir);
                     }
@@ -1406,7 +1410,7 @@ impl PathBuf {
     fn _set_file_name(&mut self, file_name: &OsStr) {
         if self.file_name().is_some() {
             let popped = self.pop();
-            debug_assert!(popped);
+            assert!(popped, "unexpected error during unwrap file name");
         }
         self.push(file_name);
     }

library/std/src/sys/unix/fs.rs

@@ -636,7 +636,7 @@ impl Iterator for ReadDir {
 impl Drop for Dir {
     fn drop(&mut self) {
         let r = unsafe { libc::closedir(self.0) };
-        debug_assert_eq!(r, 0);
+        assert_eq!(r, 0, "unexpected error during closedir: {:?}", r);
     }
 }
 

library/std/src/sys/unix/locks/pthread_condvar.rs

@@ -80,19 +80,19 @@ impl Condvar {
     #[inline]
     pub unsafe fn notify_one(&self) {
         let r = libc::pthread_cond_signal(self.inner.get());
-        debug_assert_eq!(r, 0);
+        assert_eq!(r, 0, "unexpected error during pthread_cond_signal: {:?}", r);
     }
 
     #[inline]
     pub unsafe fn notify_all(&self) {
         let r = libc::pthread_cond_broadcast(self.inner.get());
-        debug_assert_eq!(r, 0);
+        assert_eq!(r, 0, "unexpected error during pthread_cond_broadcast: {:?}", r);
     }
 
     #[inline]
     pub unsafe fn wait(&self, mutex: &Mutex) {
         let r = libc::pthread_cond_wait(self.inner.get(), pthread_mutex::raw(mutex));
-        debug_assert_eq!(r, 0);
+        assert_eq!(r, 0, "unexpected error during pthread_cond_wait: {:?}");
     }
 
     // This implementation is used on systems that support pthread_condattr_setclock
@@ -168,7 +168,7 @@ impl Condvar {
         let mut sys_now = libc::timeval { tv_sec: 0, tv_usec: 0 };
         let stable_now = Instant::now();
         let r = libc::gettimeofday(&mut sys_now, ptr::null_mut());
-        debug_assert_eq!(r, 0);
+        assert_eq!(r, 0, "unexpected error during gettimeofday: {:?}", r);
 
         let nsec = dur.subsec_nanos() as libc::c_long + (sys_now.tv_usec * 1000) as libc::c_long;
         let extra = (nsec / 1_000_000_000) as libc::time_t;
@@ -184,7 +184,11 @@ impl Condvar {
 
         // And wait!
         let r = libc::pthread_cond_timedwait(self.inner.get(), pthread_mutex::raw(mutex), &timeout);
-        debug_assert!(r == libc::ETIMEDOUT || r == 0);
+        assert!(
+            r == libc::ETIMEDOUT || r == 0,
+            "unexpected error during pthread_conf_timedwait: {:?}",
+            r
+        );
 
         // ETIMEDOUT is not a totally reliable method of determining timeout due
         // to clock shifts, so do the check ourselves
@@ -195,7 +199,7 @@ impl Condvar {
     #[cfg(not(target_os = "dragonfly"))]
     unsafe fn destroy(&mut self) {
         let r = libc::pthread_cond_destroy(self.inner.get());
-        debug_assert_eq!(r, 0);
+        assert_eq!(r, 0, "unexpected error during pthread_cond_destroy: {:?}", r);
     }
 
     #[inline]
@@ -206,7 +210,11 @@ impl Condvar {
         // a condvar that was just initialized with
         // libc::PTHREAD_COND_INITIALIZER. Once it is used or
         // pthread_cond_init() is called, this behaviour no longer occurs.
-        debug_assert!(r == 0 || r == libc::EINVAL);
+        assert!(
+            r == 0 || r == libc::EINVAL,
+            "unexpected error during pthread_cond_destroy: {:?}",
+            r
+        );
     }
 }
 

library/std/src/sys/unix/locks/pthread_mutex.rs

@@ -87,12 +87,12 @@ impl Mutex {
     #[inline]
     pub unsafe fn lock(&self) {
         let r = libc::pthread_mutex_lock(self.inner.get());
-        debug_assert_eq!(r, 0);
+        assert_eq!(r, 0, "unexpected error during pthread_mutex_lock: {:?}", r);
     }
     #[inline]
     pub unsafe fn unlock(&self) {
         let r = libc::pthread_mutex_unlock(self.inner.get());
-        debug_assert_eq!(r, 0);
+        assert_eq!(r, 0, "unexpected error during pthread_mutex_unlock: {:?}", r);
     }
     #[inline]
     pub unsafe fn try_lock(&self) -> bool {
@@ -102,7 +102,7 @@ impl Mutex {
     #[cfg(not(target_os = "dragonfly"))]
     unsafe fn destroy(&mut self) {
         let r = libc::pthread_mutex_destroy(self.inner.get());
-        debug_assert_eq!(r, 0);
+        assert_eq!(r, 0, "unexpected error during pthread_mutex_destroy: {:?}", r);
     }
     #[inline]
     #[cfg(target_os = "dragonfly")]
@@ -112,7 +112,11 @@ impl Mutex {
         // mutex that was just initialized with libc::PTHREAD_MUTEX_INITIALIZER.
         // Once it is used (locked/unlocked) or pthread_mutex_init() is called,
         // this behaviour no longer occurs.
-        debug_assert!(r == 0 || r == libc::EINVAL);
+        assert!(
+            r == 0 || r == libc::EINVAL,
+            "unexpected error during pthread_mutex_destroy: {:?}",
+            r
+        );
     }
 }
 
@@ -129,7 +133,11 @@ impl Drop for PthreadMutexAttr<'_> {
     fn drop(&mut self) {
         unsafe {
             let result = libc::pthread_mutexattr_destroy(self.0.as_mut_ptr());
-            debug_assert_eq!(result, 0);
+            assert_eq!(
+                result, 0,
+                "unexpected error during: pthread_mutexattr_destroy: {:?}",
+                result
+            );
         }
     }
 }

library/std/src/sys/unix/locks/pthread_rwlock.rs

@@ -112,7 +112,7 @@ impl RwLock {
         } else {
             // According to POSIX, for a properly initialized rwlock this can only
             // return EDEADLK or 0. We rely on that.
-            debug_assert_eq!(r, 0);
+            assert_eq!(r, 0, "unexpected error during pthread_rwlock_wrlock: {:?}", r);
         }
         *self.write_locked.get() = true;
     }
@@ -135,18 +135,18 @@ impl RwLock {
     #[inline]
     unsafe fn raw_unlock(&self) {
         let r = libc::pthread_rwlock_unlock(self.inner.get());
-        debug_assert_eq!(r, 0);
+        assert_eq!(r, 0, "unexpected error during pthread_rwlock_unlock: {:?}", r);
     }
     #[inline]
     pub unsafe fn read_unlock(&self) {
-        debug_assert!(!*self.write_locked.get());
+        assert!(!*self.write_locked.get(), "trying to unlock a thread already unlocked");
         self.num_readers.fetch_sub(1, Ordering::Relaxed);
         self.raw_unlock();
     }
     #[inline]
     pub unsafe fn write_unlock(&self) {
         debug_assert_eq!(self.num_readers.load(Ordering::Relaxed), 0);
-        debug_assert!(*self.write_locked.get());
+        assert!(*self.write_locked.get(), "trying to unlock a thread already unlocked");
         *self.write_locked.get() = false;
         self.raw_unlock();
     }
@@ -158,9 +158,13 @@ impl RwLock {
         // libc::PTHREAD_RWLOCK_INITIALIZER. Once it is used (locked/unlocked)
         // or pthread_rwlock_init() is called, this behaviour no longer occurs.
         if cfg!(target_os = "dragonfly") {
-            debug_assert!(r == 0 || r == libc::EINVAL);
+            assert!(
+                r == 0 || r == libc::EINVAL,
+                "unexpected error during pthread_rwlock_destroy: {:?}",
+                r
+            );
         } else {
-            debug_assert_eq!(r, 0);
+            assert_eq!(r, 0, "unexpected error during pthread_rwlock_destroy: {:?}", r);
         }
     }
 }

library/std/src/sys/unix/thread.rs

@@ -113,7 +113,7 @@ impl Thread {
 
     pub fn yield_now() {
         let ret = unsafe { libc::sched_yield() };
-        debug_assert_eq!(ret, 0);
+        assert_eq!(ret, 0, "unexpected error during sched_yield: {:?}", ret);
     }
 
     #[cfg(any(target_os = "linux", target_os = "android"))]
@@ -267,7 +267,7 @@ impl Thread {
 impl Drop for Thread {
     fn drop(&mut self) {
         let ret = unsafe { libc::pthread_detach(self.id) };
-        debug_assert_eq!(ret, 0);
+        assert_eq!(ret, 0, "unexpected error during pthread_detach: {:?}", ret);
     }
 }