Auto merge of #134938 - saethlin:include-precondition-args, r=<try>

Include arguments to the precondition check in failure messages

Author: bors

library/core/src/alloc/layout.rs

@@ -133,7 +133,7 @@ impl Layout {
         assert_unsafe_precondition!(
             check_library_ub,
             "Layout::from_size_align_unchecked requires that align is a power of 2 \
-            and the rounded-up allocation size does not exceed isize::MAX",
+            and the rounded-up allocation size does not exceed isize::MAX (size:{size}, align:{align})",
             (
                 size: usize = size,
                 align: usize = align,

library/core/src/ascii/ascii_char.rs

@@ -521,7 +521,7 @@ impl AsciiChar {
     pub const unsafe fn digit_unchecked(d: u8) -> Self {
         assert_unsafe_precondition!(
             check_library_ub,
-            "`ascii::Char::digit_unchecked` input cannot exceed 9.",
+            "`ascii::Char::digit_unchecked` input cannot exceed 9. (d:{d})",
             (d: u8 = d) => d < 10
         );
 

library/core/src/char/convert.rs

@@ -28,7 +28,7 @@ pub(super) const unsafe fn from_u32_unchecked(i: u32) -> char {
     unsafe {
         assert_unsafe_precondition!(
             check_language_ub,
-            "invalid value for `char`",
+            "invalid value for `char` ({i})",
             (i: u32 = i) => char_try_from_u32(i).is_ok()
         );
         transmute(i)

library/core/src/char/methods.rs

@@ -1859,8 +1859,9 @@ impl char {
     pub const unsafe fn as_ascii_unchecked(&self) -> ascii::Char {
         assert_unsafe_precondition!(
             check_library_ub,
-            "as_ascii_unchecked requires that the char is valid ASCII",
-            (it: &char = self) => it.is_ascii()
+            "as_ascii_unchecked requires that the char is valid ASCII \
+            (self:{it})",
+            (it: char = *self) => it.is_ascii()
         );
 
         // SAFETY: the caller promised that this char is ASCII.

library/core/src/displaywrapper.rs

@@ -0,0 +1,111 @@
+use core::fmt::{Display, Formatter, Result};
+use core::num::NonZeroU128;
+
+#[allow(missing_debug_implementations)]
+pub struct DisplayWrapper<T>(pub T);
+
+macro_rules! display_int {
+    ($ty:ty) => {
+        impl Display for DisplayWrapper<$ty> {
+            fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+                let n = self.0;
+                let is_negative = n < 0;
+                let n = (!(n as u128)).wrapping_add(1);
+                display_int(n, is_negative, f)
+            }
+        }
+    };
+}
+
+display_int!(i8);
+display_int!(i16);
+display_int!(i32);
+display_int!(i64);
+display_int!(i128);
+display_int!(isize);
+
+macro_rules! display_uint {
+    ($ty:ty) => {
+        impl Display for DisplayWrapper<$ty> {
+            fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+                display_int(self.0 as u128, false, f)
+            }
+        }
+    };
+}
+
+display_uint!(u8);
+display_uint!(u16);
+display_uint!(u32);
+display_uint!(u64);
+display_uint!(u128);
+display_uint!(usize);
+
+impl Display for DisplayWrapper<*const ()> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+        format_ptr(self.0.addr(), f)
+    }
+}
+impl Display for DisplayWrapper<*mut ()> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+        format_ptr(self.0.addr(), f)
+    }
+}
+
+impl Display for DisplayWrapper<char> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+        let mut buf = [0u8; 4];
+        let s = self.0.encode_utf8(&mut buf);
+        f.write_str(s)
+    }
+}
+
+impl Display for DisplayWrapper<bool> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+        let s = match self.0 {
+            true => "true",
+            false => "false",
+        };
+        f.write_str(s)
+    }
+}
+
+const ALPHABET: &[u8; 16] = b"0123456789abcdef";
+
+fn format_with_radix(mut n: u128, buf: &mut [u8], radix: NonZeroU128) -> usize {
+    let mut cur = buf.len();
+    while n >= radix.get() {
+        let d = n % radix;
+        n /= radix;
+        cur = cur.wrapping_sub(1);
+        buf[cur] = ALPHABET[d as usize];
+    }
+    cur = cur.wrapping_sub(1);
+    buf[cur] = ALPHABET[n as usize];
+    cur
+}
+
+pub fn format_ptr(addr: usize, f: &mut Formatter<'_>) -> Result {
+    let mut buf = [b'0'; 42];
+    let mut cur =
+        format_with_radix(addr as u128, &mut buf, const { NonZeroU128::new(16).unwrap() });
+
+    cur = cur.wrapping_sub(1);
+    buf[cur] = b'x';
+    cur = cur.wrapping_sub(1);
+
+    // SAFETY: The buffer is initially ASCII and we only write ASCII bytes to it.
+    let s = unsafe { core::str::from_utf8_unchecked(&buf[cur..]) };
+    f.write_str(s)
+}
+
+pub fn display_int(n: u128, is_negative: bool, f: &mut Formatter<'_>) -> Result {
+    let mut buf = [b'-'; 42];
+    let mut cur = format_with_radix(n, &mut buf, const { NonZeroU128::new(10).unwrap() });
+    if is_negative {
+        cur = cur.wrapping_sub(1);
+    }
+    // SAFETY: The buffer is initially ASCII and we only write ASCII bytes to it.
+    let s = unsafe { core::str::from_utf8_unchecked(&buf[cur..]) };
+    f.write_str(s)
+}

library/core/src/fmt/mod.rs

@@ -2096,6 +2096,7 @@ impl<'a> Formatter<'a> {
     /// assert_eq!(format!("{Foo:0>8}"), "Foo");
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
+    #[inline]
     pub fn write_str(&mut self, data: &str) -> Result {
         self.buf.write_str(data)
     }

library/core/src/intrinsics/mod.rs

@@ -2424,7 +2424,7 @@ where
 /// macro supports setting attributes for those functions. Both functions are marked as `#[inline]`.
 ///
 /// See [`const_eval_select()`] for the rules and requirements around that intrinsic.
-pub(crate) macro const_eval_select {
+pub macro const_eval_select {
     (
         @capture$([$($binders:tt)*])? { $($arg:ident : $ty:ty = $val:expr),* $(,)? } $( -> $ret:ty )? :
         if const

library/core/src/lib.rs

@@ -347,6 +347,9 @@ pub mod alloc;
 
 // note: does not need to be public
 mod bool;
+#[doc(hidden)]
+#[unstable(feature = "ub_checks", issue = "none")]
+pub mod displaywrapper;
 mod escape;
 mod tuple;
 mod unit;

library/core/src/mem/alignment.rs

@@ -188,7 +188,8 @@ impl Alignment {
     pub const unsafe fn new_unchecked(align: usize) -> Self {
         assert_unsafe_precondition!(
             check_language_ub,
-            "Alignment::new_unchecked requires a power of two",
+            "Alignment::new_unchecked requires a power of two \
+            (align:{align})",
             (align: usize = align) => align.is_power_of_two()
         );
 

library/core/src/num/mod.rs

@@ -651,7 +651,7 @@ impl u8 {
         assert_unsafe_precondition!(
             check_library_ub,
             "as_ascii_unchecked requires that the byte is valid ASCII",
-            (it: &u8 = self) => it.is_ascii()
+            (it: u8 = *self) => it.is_ascii()
         );
 
         // SAFETY: the caller promised that this byte is ASCII.