Cleanup

Author: saethlin

library/core/src/intrinsics.rs

@@ -2570,15 +2570,14 @@ extern "rust-intrinsic" {
     #[cfg(not(bootstrap))]
     pub fn is_val_statically_known<T: Copy>(arg: T) -> bool;
 
-    #[rustc_const_stable(feature = "delayed_debug_assertions", since = "0.0.0")]
+    #[rustc_const_unstable(feature = "delayed_debug_assertions", issue = "none")]
     #[rustc_safe_intrinsic]
-    #[rustc_nounwind]
     #[cfg(not(bootstrap))]
     pub(crate) fn debug_assertions() -> bool;
 }
 
 #[cfg(bootstrap)]
-#[rustc_const_stable(feature = "delayed_debug_assertions", since = "0.0.0")]
+#[rustc_const_unstable(feature = "delayed_debug_assertions", issue = "none")]
 pub(crate) const fn debug_assertions() -> bool {
     cfg!(debug_assertions)
 }
@@ -2599,9 +2598,27 @@ pub const unsafe fn is_val_statically_known<T: Copy>(_arg: T) -> bool {
 /// Check that the preconditions of an unsafe function are followed, if debug_assertions are on,
 /// and only at runtime.
 ///
-/// This macro should be called as `assert_unsafe_precondition!((name: Type) => Expression)`
-/// where the names specified will be moved into the macro as captured variables, and defines an item
-/// to call `const_eval_select` on.
+/// This macro should be called as
+/// `assert_unsafe_precondition!((expr => name: Type, expr => name: Type) => Expression)`
+/// where each `expr` will be evaluated and passed in as function argument `name: Type`. Then all
+/// those arguments are passed to a function via [`const_eval_select`].
+///
+/// These checks are behind a condition which is evaluated at codegen time, not expansion time like
+/// [`debug_assert`]. This means that a standard library built with optimizations and debug
+/// assertions disabled will have these checks optimized out of its monomorphizations, but if a
+/// a caller of the standard library has debug assertions enabled and monomorphizes an expansion of
+/// this macro, that monomorphization will contain the check.
+///
+/// Since these checks cannot be optimized out in MIR, some care must be taken in both call and
+/// implementation to mitigate their compile-time overhead. The runtime function that we
+/// [`const_eval_select`] to is monomorphic, `#[inline(never)]`, and `#[rustc_nounwind]`. That
+/// combination of properties ensures that the code for the checks is only compiled once, and has a
+/// minimal impact on the caller's code size.
+///
+/// Caller should also introducing any other `let` bindings or any code outside this macro in order
+/// to call it. Since the precompiled standard library is built with full debuginfo and these
+/// variables cannot be optimized out in MIR, an innocent-looking `let` can produce enough
+/// debuginfo to have a measurable compile-time impact on debug builds.
 ///
 /// # Safety
 ///
@@ -2619,21 +2636,20 @@ pub const unsafe fn is_val_statically_known<T: Copy>(_arg: T) -> bool {
 macro_rules! assert_unsafe_precondition {
     ($message:expr, ($($arg:expr => $name:ident:$ty:ty),*$(,)?) => $e:expr $(,)?) => {
         {
-        #[inline(never)]
-        #[rustc_nounwind]
-        fn precondition_check($($name:$ty),*) {
-            if !$e {
-                ::core::panicking::panic_nounwind(
-                    concat!("unsafe precondition(s) violated: ", $message)
-                );
+            #[inline(never)]
+            #[rustc_nounwind]
+            fn precondition_check($($name:$ty),*) {
+                if !$e {
+                    ::core::panicking::panic_nounwind(
+                        concat!("unsafe precondition(s) violated: ", $message)
+                    );
+                }
             }
-        }
-        #[inline]
-        const fn comptime($(_:$ty),*) {}
+            const fn comptime($(_:$ty),*) {}
 
-        if ::core::intrinsics::debug_assertions() {
-            ::core::intrinsics::const_eval_select(($($arg,)*), comptime, precondition_check);
-        }
+            if ::core::intrinsics::debug_assertions() {
+                ::core::intrinsics::const_eval_select(($($arg,)*), comptime, precondition_check);
+            }
         }
     };
 }