Report arguments from assert_unsafe_precondition

Author: saethlin

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

@@ -4,7 +4,7 @@ use super::*;
 use crate::panic::const_panic;
 use crate::slice;
 use crate::str::from_utf8_unchecked_mut;
-use crate::ub_checks::assert_unsafe_precondition;
+//use crate::ub_checks::assert_unsafe_precondition;
 use crate::unicode::printable::is_printable;
 use crate::unicode::{self, conversions};
 
@@ -1258,11 +1258,13 @@ impl char {
     #[unstable(feature = "ascii_char", issue = "110998")]
     #[inline]
     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()
         );
+        */
 
         // SAFETY: the caller promised that this char is ASCII.
         unsafe { ascii::Char::from_u8_unchecked(*self as u8) }

library/core/src/displaywrapper.rs

@@ -0,0 +1,144 @@
+use core::fmt::{Display, Formatter, Result};
+
+#[allow(missing_debug_implementations)]
+#[unstable(feature = "ub_checks", issue = "none")]
+pub struct DisplayWrapper<T>(#[unstable(feature = "ub_checks", issue = "none")] pub T);
+
+trait Displayable: Sized + Clone + Copy {
+    const IS_POINTER: bool;
+    const SIGNED: bool;
+    #[inline]
+    fn addr(self) -> usize {
+        unimplemented!()
+    }
+    #[inline]
+    fn as_u128(self) -> u128 {
+        unimplemented!()
+    }
+    #[inline]
+    fn as_i128(self) -> i128 {
+        unimplemented!()
+    }
+}
+
+impl<T> Displayable for *const T {
+    const IS_POINTER: bool = true;
+    const SIGNED: bool = false;
+    #[inline]
+    fn addr(self) -> usize {
+        self.addr()
+    }
+}
+impl<T> Displayable for *mut T {
+    const IS_POINTER: bool = true;
+    const SIGNED: bool = false;
+    #[inline]
+    fn addr(self) -> usize {
+        self.addr()
+    }
+}
+impl Displayable for u8 {
+    const IS_POINTER: bool = false;
+    const SIGNED: bool = false;
+    #[inline]
+    fn as_u128(self) -> u128 {
+        self as u128
+    }
+}
+impl Displayable for u32 {
+    const IS_POINTER: bool = false;
+    const SIGNED: bool = false;
+    #[inline]
+    fn as_u128(self) -> u128 {
+        self as u128
+    }
+}
+impl Displayable for u64 {
+    const IS_POINTER: bool = false;
+    const SIGNED: bool = false;
+    #[inline]
+    fn as_u128(self) -> u128 {
+        self as u128
+    }
+}
+impl Displayable for usize {
+    const IS_POINTER: bool = false;
+    const SIGNED: bool = false;
+    #[inline]
+    fn as_u128(self) -> u128 {
+        self as u128
+    }
+}
+impl Displayable for u128 {
+    const IS_POINTER: bool = false;
+    const SIGNED: bool = false;
+    #[inline]
+    fn as_u128(self) -> u128 {
+        self
+    }
+}
+
+impl Displayable for isize {
+    const IS_POINTER: bool = false;
+    const SIGNED: bool = true;
+    #[inline]
+    fn as_i128(self) -> i128 {
+        self as i128
+    }
+}
+impl Displayable for i128 {
+    const IS_POINTER: bool = false;
+    const SIGNED: bool = true;
+    #[inline]
+    fn as_i128(self) -> i128 {
+        self
+    }
+}
+#[unstable(feature = "ub_checks", issue = "none")]
+impl<T: Displayable> Display for DisplayWrapper<T> {
+    #[inline]
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+        const HEX: [u8; 16] = *b"0123456789abcdef";
+        let mut buf = [0u8; 42];
+        let mut cur = buf.len();
+        if T::IS_POINTER {
+            let mut n = self.0.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';
+        } else {
+            let mut is_negative = false;
+            let mut n = if T::SIGNED {
+                let signed = self.0.as_i128();
+                is_negative = signed < 0;
+                (!(signed as u128)).wrapping_add(1)
+            } else {
+                self.0.as_u128()
+            };
+            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'-';
+            }
+        }
+        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

@@ -350,6 +350,9 @@ mod bool;
 mod escape;
 mod tuple;
 mod unit;
+#[doc(hidden)]
+#[unstable(feature = "ub_checks", issue = "none")]
+pub mod displaywrapper;
 
 #[stable(feature = "core_primitive", since = "1.43.0")]
 pub mod primitive;

library/core/src/num/mod.rs

@@ -506,11 +506,13 @@ impl u8 {
     #[unstable(feature = "ascii_char", issue = "110998")]
     #[inline]
     pub const unsafe fn as_ascii_unchecked(&self) -> ascii::Char {
+        /*
         assert_unsafe_precondition!(
             check_library_ub,
             "as_ascii_unchecked requires that the byte is valid ASCII",
             (it: &u8 = self) => it.is_ascii()
         );
+        */
 
         // SAFETY: the caller promised that this byte is ASCII.
         unsafe { ascii::Char::from_u8_unchecked(*self) }

library/core/src/num/nonzero.rs

@@ -420,6 +420,7 @@ where
                     ub_checks::assert_unsafe_precondition!(
                         check_language_ub,
                         "NonZero::new_unchecked requires the argument to be non-zero",
+                        // FIXME: Can't print n here because of how the check is written
                         () => false,
                     );
                     intrinsics::unreachable()
@@ -461,6 +462,7 @@ where
                     ub_checks::assert_unsafe_precondition!(
                         check_library_ub,
                         "NonZero::from_mut_unchecked requires the argument to dereference as non-zero",
+                        // FIXME: Can't print n here because of how the check is written
                         () => false,
                     );
                     intrinsics::unreachable()