library: use const_block_items feature

Author: GrigorenkoPV

library/core/src/ffi/va_list.rs

@@ -302,12 +302,12 @@ impl<'f> Drop for VaListImpl<'f> {
 
 // Checks (via an assert in `compiler/rustc_ty_utils/src/abi.rs`) that the C ABI for the current
 // target correctly implements `rustc_pass_indirectly_in_non_rustic_abis`.
-const _: () = {
+const {
     #[repr(C)]
     #[rustc_pass_indirectly_in_non_rustic_abis]
     struct Type(usize);
 
     const extern "C" fn c(_: Type) {}
 
     c(Type(0))
-};
+}

library/core/src/lib.rs

@@ -144,6 +144,7 @@
 #![feature(cfg_target_has_atomic)]
 #![feature(cfg_target_has_atomic_equal_alignment)]
 #![feature(cfg_ub_checks)]
+#![feature(const_block_items)]
 #![feature(const_precise_live_drops)]
 #![feature(const_trait_impl)]
 #![feature(decl_macro)]

library/core/src/ptr/alignment.rs

@@ -15,8 +15,8 @@ use crate::{cmp, fmt, hash, mem, num};
 pub struct Alignment(AlignmentEnum);
 
 // Alignment is `repr(usize)`, but via extra steps.
-const _: () = assert!(size_of::<Alignment>() == size_of::<usize>());
-const _: () = assert!(align_of::<Alignment>() == align_of::<usize>());
+const { assert!(size_of::<Alignment>() == size_of::<usize>()) }
+const { assert!(align_of::<Alignment>() == align_of::<usize>()) }
 
 fn _alignment_can_be_structurally_matched(a: Alignment) -> bool {
     matches!(a, Alignment::MIN)

library/coretests/tests/cmp.rs

@@ -238,11 +238,11 @@ mod const_cmp {
         }
     }
 
-    const _: () = assert!(S(1) == S(1));
-    const _: () = assert!(S(0) != S(1));
+    const { assert!(S(1) == S(1)) }
+    const { assert!(S(0) != S(1)) }
 
-    const _: () = assert!(S(1) <= S(1));
-    const _: () = assert!(S(1) >= S(1));
-    const _: () = assert!(S(0) < S(1));
-    const _: () = assert!(S(1) > S(0));
+    const { assert!(S(1) <= S(1)) }
+    const { assert!(S(1) >= S(1)) }
+    const { assert!(S(0) < S(1)) }
+    const { assert!(S(1) > S(0)) }
 }

library/coretests/tests/lib.rs

@@ -16,6 +16,7 @@
 #![feature(char_internals)]
 #![feature(char_max_len)]
 #![feature(clone_to_uninit)]
+#![feature(const_block_items)]
 #![feature(const_cell_traits)]
 #![feature(const_cmp)]
 #![feature(const_convert)]

library/std/src/sys/pal/sgx/libunwind_integration.rs

@@ -9,8 +9,8 @@ use crate::{slice, str};
 // Verify that the byte pattern libunwind uses to initialize an RwLock is
 // equivalent to the value of RwLock::new(). If the value changes,
 // `src/UnwindRustSgx.h` in libunwind needs to be changed too.
-const _: () = unsafe {
-    let bits_rust: usize = crate::mem::transmute(RwLock::new());
+const {
+    let bits_rust: usize = unsafe { crate::mem::transmute(RwLock::new()) };
     assert!(bits_rust == 0);
 };
 

library/std/tests/sync/barrier.rs

@@ -38,7 +38,7 @@ fn test_barrier() {
 /// Asserts that `Barrier` is ref unwind safe.
 ///
 /// See <https://github.com/rust-lang/rust/issues/146087>.
-const _: () = {
+const {
     const fn check_ref_unwind_safe<T: RefUnwindSafe>() {}
     check_ref_unwind_safe::<Barrier>();
-};
+}

library/std/tests/sync/lib.rs

@@ -1,3 +1,4 @@
+#![feature(const_block_items)]
 #![feature(lazy_get)]
 #![feature(mapped_lock_guards)]
 #![feature(mpmc_channel)]