std: promote debug_assert to assert

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/io/error/repr_bitpacked.rs

@@ -145,7 +145,7 @@ impl Repr {
         let p = Box::into_raw(b).cast::<u8>();
         // Should only be possible if an allocator handed out a pointer with
         // wrong alignment.
-        debug_assert_eq!(p.addr() & TAG_MASK, 0);
+        assert_eq!(p.addr() & TAG_MASK, 0);
         // Note: We know `TAG_CUSTOM <= size_of::<Custom>()` (static_assert at
         // end of file), and both the start and end of the expression must be
         // valid without address space wraparound due to `Box`'s semantics.
@@ -167,7 +167,7 @@ impl Repr {
         let res = Self(unsafe { NonNull::new_unchecked(tagged) }, PhantomData);
         // quickly smoke-check we encoded the right thing (This generally will
         // only run in libstd's tests, unless the user uses -Zbuild-std)
-        debug_assert!(matches!(res.data(), ErrorData::Custom(_)), "repr(custom) encoding failed");
+        assert!(matches!(res.data(), ErrorData::Custom(_)), "repr(custom) encoding failed");
         res
     }
 
@@ -178,7 +178,7 @@ impl Repr {
         let res = Self(unsafe { NonNull::new_unchecked(ptr::invalid_mut(utagged)) }, PhantomData);
         // quickly smoke-check we encoded the right thing (This generally will
         // only run in libstd's tests, unless the user uses -Zbuild-std)
-        debug_assert!(
+        assert!(
             matches!(res.data(), ErrorData::Os(c) if c == code),
             "repr(os) encoding failed for {code}"
         );
@@ -192,7 +192,7 @@ impl Repr {
         let res = Self(unsafe { NonNull::new_unchecked(ptr::invalid_mut(utagged)) }, PhantomData);
         // quickly smoke-check we encoded the right thing (This generally will
         // only run in libstd's tests, unless the user uses -Zbuild-std)
-        debug_assert!(
+        assert!(
             matches!(res.data(), ErrorData::Simple(k) if k == kind),
             "repr(simple) encoding failed {:?}",
             kind,
@@ -256,7 +256,7 @@ where
         TAG_SIMPLE => {
             let kind_bits = (bits >> 32) as u32;
             let kind = kind_from_prim(kind_bits).unwrap_or_else(|| {
-                debug_assert!(false, "Invalid io::error::Repr bits: `Repr({:#018x})`", bits);
+                assert!(false, "Invalid io::error::Repr bits: `Repr({:#018x})`", bits);
                 // This means the `ptr` passed in was not valid, which violates
                 // the unsafe contract of `decode_repr`.
                 //

library/std/src/os/windows/io/socket.rs

@@ -193,7 +193,7 @@ impl IntoRawSocket for OwnedSocket {
 impl FromRawSocket for OwnedSocket {
     #[inline]
     unsafe fn from_raw_socket(socket: RawSocket) -> Self {
-        debug_assert_ne!(socket, c::INVALID_SOCKET as RawSocket);
+        assert_ne!(socket, c::INVALID_SOCKET as RawSocket);
         Self { socket }
     }
 }

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/sync/mpsc/oneshot.rs

@@ -138,7 +138,7 @@ impl<T> Packet<T> {
                     }
                 } else {
                     wait_token.wait();
-                    debug_assert!(self.state.load(Ordering::SeqCst) != EMPTY);
+                    assert!(self.state.load(Ordering::SeqCst) != EMPTY, "packet state not empity");
                 }
             } else {
                 // drop the signal token, since we never blocked

library/std/src/sync/once_lock.rs

@@ -217,7 +217,7 @@ impl<T> OnceLock<T> {
         }
         self.initialize(f)?;
 
-        debug_assert!(self.is_initialized());
+        assert!(self.is_initialized(), "bad initialization");
 
         // SAFETY: The inner value has been initialized
         Ok(unsafe { self.get_unchecked() })
@@ -369,15 +369,15 @@ impl<T> OnceLock<T> {
     ///
     /// The value must be initialized
     unsafe fn get_unchecked(&self) -> &T {
-        debug_assert!(self.is_initialized());
+        assert!(self.is_initialized(), "value not initialized");
         (&*self.value.get()).assume_init_ref()
     }
 
     /// # Safety
     ///
     /// The value must be initialized
     unsafe fn get_unchecked_mut(&mut self) -> &mut T {
-        debug_assert!(self.is_initialized());
+        assert!(self.is_initialized(), "value not initialized");
         (&mut *self.value.get()).assume_init_mut()
     }
 }

library/std/src/sys/itron/condvar.rs

@@ -157,7 +157,7 @@ mod waiter_queue {
             // Zeroness of `Waiter::task` indicates whether the `Waiter` is
             // linked to a queue or not. This invariant is important for
             // the correctness.
-            debug_assert_ne!(task, 0);
+            assert_ne!(task, 0);
 
             Self { task, priority, prev: None, next: None }
         }
@@ -182,8 +182,8 @@ mod waiter_queue {
             unsafe {
                 let waiter = waiter_ptr.as_mut();
 
-                debug_assert!(waiter.prev.is_none());
-                debug_assert!(waiter.next.is_none());
+                assert!(waiter.prev.is_none());
+                assert!(waiter.next.is_none());
 
                 if let Some(head) = &mut self.head {
                     // Find the insertion position and insert `waiter`

library/std/src/sys/itron/spin.rs

@@ -34,7 +34,7 @@ impl<T> SpinMutex<T> {
         let _guard;
         if unsafe { abi::sns_dsp() } == 0 {
             let er = unsafe { abi::dis_dsp() };
-            debug_assert!(er >= 0);
+            assert!(er >= 0, "unexpected error during abi::dis_dsp(): {:?}", ret);
 
             // Wait until the current processor acquires a lock.
             while self.locked.swap(true, Ordering::Acquire) {}
@@ -95,11 +95,11 @@ impl<T> SpinIdOnceCell<T> {
     /// Assign the content without checking if it's already initialized or
     /// being initialized.
     pub unsafe fn set_unchecked(&self, (id, extra): (abi::ID, T)) {
-        debug_assert!(self.get().is_none());
+        assert!(self.get().is_none());
 
         // Assumption: A positive `abi::ID` fits in `usize`.
-        debug_assert!(id >= 0);
-        debug_assert!(usize::try_from(id).is_ok());
+        assert!(id >= 0, "negative `abi::ID` received: {:?}", id);
+        assert!(usize::try_from(id).is_ok(), "fails to conver `abi::ID` to `usize`: {:?}", id);
         let id = id as usize;
 
         unsafe { *self.extra.get() = MaybeUninit::new(extra) };
@@ -124,7 +124,7 @@ impl<T> SpinIdOnceCell<T> {
 
         self.initialize(f)?;
 
-        debug_assert!(self.get().is_some());
+        assert!(self.get().is_some());
 
         // Safety: The inner value has been initialized
         Ok(unsafe { self.get_unchecked() })
@@ -139,8 +139,11 @@ impl<T> SpinIdOnceCell<T> {
                 let (initialized_id, initialized_extra) = f()?;
 
                 // Assumption: A positive `abi::ID` fits in `usize`.
-                debug_assert!(initialized_id >= 0);
-                debug_assert!(usize::try_from(initialized_id).is_ok());
+                assert!(initialized_id >= 0, "negative `abi::ID`");
+                assert!(
+                    usize::try_from(initialized_id).is_ok(),
+                    "fails to conver `abi::ID` to `usize`: {:?}"
+                );
                 let initialized_id = initialized_id as usize;
 
                 // Store the initialized contents. Use the release ordering to

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

@@ -202,9 +202,21 @@ impl Thread {
         // Get the current task ID. Panicking here would cause a resource leak,
         // so just abort on failure.
         let current_task = task::current_task_id_aborting();
-        debug_assert!(usize::try_from(current_task).is_ok());
-        debug_assert_ne!(current_task as usize, LIFECYCLE_INIT);
-        debug_assert_ne!(current_task as usize, LIFECYCLE_DETACHED);
+        assert!(
+            usize::try_from(current_task).is_ok(),
+            "fails to convert `current_task_id` to `usize`: {:?}",
+            current_task
+        );
+        assert_ne!(
+            current_task as usize, LIFECYCLE_INIT,
+            "`current_task` is not in a valid state: {:?}",
+            current_task
+        );
+        assert_ne!(
+            current_task as usize, LIFECYCLE_DETACHED,
+            "`current_task` is not in a valid state: {:?}",
+            current_task
+        );
 
         let current_task = current_task as usize;
 

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!(r == 0 || r == libc::EINTR, "unexpected error during closedir: {:?}", r);
     }
 }
 

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

@@ -95,7 +95,11 @@ impl RwLock {
 
         // It's impossible for a reader to be waiting on a read-locked RwLock,
         // except if there is also a writer waiting.
-        debug_assert!(!has_readers_waiting(state) || has_writers_waiting(state));
+        assert!(
+            !has_readers_waiting(state) || has_writers_waiting(state),
+            "invalid read state: {:?}",
+            state
+        );
 
         // Wake up a writer if we were the last reader and there's a writer waiting.
         if is_unlocked(state) && has_writers_waiting(state) {
@@ -161,7 +165,7 @@ impl RwLock {
     pub unsafe fn write_unlock(&self) {
         let state = self.state.fetch_sub(WRITE_LOCKED, Release) - WRITE_LOCKED;
 
-        debug_assert!(is_unlocked(state));
+        assert!(is_unlocked(state), "trying to write while the state is invalid: {:?}", state);
 
         if has_writers_waiting(state) || has_readers_waiting(state) {
             self.wake_writer_or_readers(state);