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

Include arguments to the precondition check in failure messages

Author: rust-bors[bot]

library/core/src/alloc/layout.rs

@@ -131,7 +131,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

@@ -516,7 +516,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

@@ -1260,8 +1260,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,168 @@
+use core::fmt::{Display, Formatter, Result};
+
+#[allow(missing_debug_implementations)]
+#[unstable(feature = "ub_checks", issue = "none")]
+pub enum DisplayWrapper<'a> {
+    Bool(bool),
+    Char(char),
+    Str(&'a str),
+    Ptr(*const ()),
+    Uint(u128),
+    Int(i128),
+}
+
+impl From<bool> for DisplayWrapper<'_> {
+    fn from(b: bool) -> Self {
+        Self::Bool(b)
+    }
+}
+
+impl<'a> From<&'a str> for DisplayWrapper<'a> {
+    fn from(s: &'a str) -> Self {
+        Self::Str(s)
+    }
+}
+
+impl From<char> for DisplayWrapper<'_> {
+    fn from(c: char) -> Self {
+        Self::Char(c)
+    }
+}
+
+impl From<*const ()> for DisplayWrapper<'_> {
+    fn from(c: *const ()) -> Self {
+        Self::Ptr(c)
+    }
+}
+impl From<*mut ()> for DisplayWrapper<'_> {
+    fn from(c: *mut ()) -> Self {
+        Self::Ptr(c as *const ())
+    }
+}
+
+impl From<u8> for DisplayWrapper<'_> {
+    fn from(c: u8) -> Self {
+        Self::Uint(c as u128)
+    }
+}
+impl From<u16> for DisplayWrapper<'_> {
+    fn from(c: u16) -> Self {
+        Self::Uint(c as u128)
+    }
+}
+impl From<u32> for DisplayWrapper<'_> {
+    fn from(c: u32) -> Self {
+        Self::Uint(c as u128)
+    }
+}
+impl From<u64> for DisplayWrapper<'_> {
+    fn from(c: u64) -> Self {
+        Self::Uint(c as u128)
+    }
+}
+impl From<u128> for DisplayWrapper<'_> {
+    fn from(c: u128) -> Self {
+        Self::Uint(c as u128)
+    }
+}
+impl From<usize> for DisplayWrapper<'_> {
+    fn from(c: usize) -> Self {
+        Self::Uint(c as u128)
+    }
+}
+
+impl From<i8> for DisplayWrapper<'_> {
+    fn from(c: i8) -> Self {
+        Self::Int(c as i128)
+    }
+}
+impl From<i16> for DisplayWrapper<'_> {
+    fn from(c: i16) -> Self {
+        Self::Int(c as i128)
+    }
+}
+impl From<i32> for DisplayWrapper<'_> {
+    fn from(c: i32) -> Self {
+        Self::Int(c as i128)
+    }
+}
+impl From<i64> for DisplayWrapper<'_> {
+    fn from(c: i64) -> Self {
+        Self::Int(c as i128)
+    }
+}
+impl From<i128> for DisplayWrapper<'_> {
+    fn from(c: i128) -> Self {
+        Self::Int(c as i128)
+    }
+}
+impl From<isize> for DisplayWrapper<'_> {
+    fn from(c: isize) -> Self {
+        Self::Int(c as i128)
+    }
+}
+
+#[unstable(feature = "ub_checks", issue = "none")]
+impl Display for DisplayWrapper<'_> {
+    #[inline]
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+        const HEX: [u8; 16] = *b"0123456789abcdef";
+        let mut buf = [0u8; 42];
+        let mut cur = buf.len();
+
+        match *self {
+            Self::Bool(_) | Self::Str(_) => panic!(),
+            Self::Char(c) => {
+                let mut buf = [0u8; 4];
+                let s = c.encode_utf8(&mut buf);
+                return f.write_str(s);
+            }
+            Self::Ptr(ptr) => {
+                let mut n = ptr.addr();
+                while n >= 16 {
+                    let d = n % 16;
+                    n /= 16;
+                    cur -= 1;
+                    buf[cur] = HEX[d];
+                }
+                cur -= 1;
+                buf[cur] = HEX[n];
+
+                cur -= 1;
+                buf[cur] = b'x';
+                cur -= 1;
+                buf[cur] = b'0';
+            }
+            Self::Uint(mut n) => {
+                while n >= 10 {
+                    let d = n % 10;
+                    n /= 10;
+                    cur -= 1;
+                    buf[cur] = (d as u8) + b'0';
+                }
+                cur -= 1;
+                buf[cur] = (n as u8) + b'0';
+            }
+            Self::Int(n) => {
+                let is_negative = n < 0;
+                let mut n = (!(n as u128)).wrapping_add(1);
+
+                while n >= 10 {
+                    let d = n % 10;
+                    n /= 10;
+                    cur -= 1;
+                    buf[cur] = (d as u8) + b'0';
+                }
+                cur -= 1;
+                buf[cur] = (n as u8) + b'0';
+                if is_negative {
+                    cur -= 1;
+                    buf[cur] = b'-';
+                }
+            }
+        }
+        // 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

@@ -1883,6 +1883,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

@@ -2388,7 +2388,7 @@ where
 /// 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/num/mod.rs

@@ -509,7 +509,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.

library/core/src/ops/index_range.rs

@@ -23,7 +23,8 @@ impl IndexRange {
     pub(crate) const unsafe fn new_unchecked(start: usize, end: usize) -> Self {
         ub_checks::assert_unsafe_precondition!(
             check_library_ub,
-            "IndexRange::new_unchecked requires `start <= end`",
+            "IndexRange::new_unchecked requires `start <= end` \
+            (start:{start}, end:{end})",
             (start: usize = start, end: usize = end) => start <= end,
         );
         IndexRange { start, end }