fix rustfmt

Author: fee1-dead

library/alloc/src/raw_vec/mod.rs

@@ -165,14 +165,14 @@ const fn min_non_zero_cap(size: usize) -> usize {
     }
 }
 
+#[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+#[rustfmt::skip] // FIXME(fee1-dead): temporary measure before rustfmt is bumped
 const impl<T, A: [const] Allocator + [const] Destruct> RawVec<T, A> {
     /// Like `with_capacity`, but parameterized over the choice of
     /// allocator for the returned `RawVec`.
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
-    pub(crate) fn with_capacity_in(capacity: usize, alloc: A) -> Self
-    {
+    pub(crate) fn with_capacity_in(capacity: usize, alloc: A) -> Self {
         Self {
             inner: RawVecInner::with_capacity_in(capacity, alloc, T::LAYOUT),
             _marker: PhantomData,
@@ -183,9 +183,7 @@ const impl<T, A: [const] Allocator + [const] Destruct> RawVec<T, A> {
     /// caller to ensure `len == self.capacity()`.
     #[cfg(not(no_global_oom_handling))]
     #[inline(never)]
-    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
-    pub(crate) fn grow_one(&mut self)
-    {
+    pub(crate) fn grow_one(&mut self) {
         // SAFETY: All calls on self.inner pass T::LAYOUT as the elem_layout
         unsafe { self.inner.grow_one(T::LAYOUT) }
     }
@@ -411,12 +409,12 @@ unsafe impl<#[may_dangle] T, A: Allocator> Drop for RawVec<T, A> {
     }
 }
 
+#[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+#[rustfmt::skip] // FIXME(fee1-dead): temporary measure before rustfmt is bumped
 const impl<A: [const] Allocator + [const] Destruct> RawVecInner<A> {
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
-    fn with_capacity_in(capacity: usize, alloc: A, elem_layout: Layout) -> Self
-    {
+    fn with_capacity_in(capacity: usize, alloc: A, elem_layout: Layout) -> Self {
         match Self::try_allocate_in(capacity, AllocInit::Uninitialized, alloc, elem_layout) {
             Ok(this) => {
                 unsafe {
@@ -428,14 +426,13 @@ const impl<A: [const] Allocator + [const] Destruct> RawVecInner<A> {
             Err(err) => handle_error(err),
         }
     }
-    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+
     fn try_allocate_in(
         capacity: usize,
         init: AllocInit,
         alloc: A,
         elem_layout: Layout,
-    ) -> Result<Self, TryReserveError>
-    {
+    ) -> Result<Self, TryReserveError> {
         // We avoid `unwrap_or_else` here because it bloats the amount of
         // LLVM IR generated.
         let layout = match layout_array(capacity, elem_layout) {
@@ -474,29 +471,24 @@ const impl<A: [const] Allocator + [const] Destruct> RawVecInner<A> {
     /// - `elem_layout`'s size must be a multiple of its alignment
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
-    unsafe fn grow_one(&mut self, elem_layout: Layout)
-    {
+    unsafe fn grow_one(&mut self, elem_layout: Layout) {
         // SAFETY: Precondition passed to caller
         if let Err(err) = unsafe { self.grow_amortized(self.cap.as_inner(), 1, elem_layout) } {
             handle_error(err);
         }
     }
 
-
     /// # Safety
     /// - `elem_layout` must be valid for `self`, i.e. it must be the same `elem_layout` used to
     ///   initially construct `self`
     /// - `elem_layout`'s size must be a multiple of its alignment
     /// - The sum of `len` and `additional` must be greater than the current capacity
-    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
     unsafe fn grow_amortized(
         &mut self,
         len: usize,
         additional: usize,
         elem_layout: Layout,
-    ) -> Result<(), TryReserveError>
-    {
+    ) -> Result<(), TryReserveError> {
         // This is ensured by the calling contexts.
         debug_assert!(additional > 0);
 
@@ -532,13 +524,11 @@ const impl<A: [const] Allocator + [const] Destruct> RawVecInner<A> {
     // not marked inline(never) since we want optimizers to be able to observe the specifics of this
     // function, see tests/codegen-llvm/vec-reserve-extend.rs.
     #[cold]
-    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
     unsafe fn finish_grow(
         &self,
         cap: usize,
         elem_layout: Layout,
-    ) -> Result<NonNull<[u8]>, TryReserveError>
-    {
+    ) -> Result<NonNull<[u8]>, TryReserveError> {
         let new_layout = layout_array(cap, elem_layout)?;
 
         let memory = if let Some((ptr, old_layout)) = unsafe { self.current_memory(elem_layout) } {

library/alloc/src/vec/mod.rs

@@ -902,6 +902,8 @@ impl<T> Vec<T> {
     }
 }
 
+#[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+#[rustfmt::skip] // FIXME(fee1-dead): temporary measure before rustfmt is bumped
 const impl<T, A: [const] Allocator + [const] Destruct> Vec<T, A> {
     /// Constructs a new, empty `Vec<T, A>` with at least the specified capacity
     /// with the provided allocator.
@@ -961,13 +963,10 @@ const impl<T, A: [const] Allocator + [const] Destruct> Vec<T, A> {
     #[cfg(not(no_global_oom_handling))]
     #[inline]
     #[unstable(feature = "allocator_api", issue = "32838")]
-    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
-    pub fn with_capacity_in(capacity: usize, alloc: A) -> Self
-    {
+    pub fn with_capacity_in(capacity: usize, alloc: A) -> Self {
         Vec { buf: RawVec::with_capacity_in(capacity, alloc), len: 0 }
     }
 
-
     /// Appends an element to the back of a collection.
     ///
     /// # Panics
@@ -992,9 +991,7 @@ const impl<T, A: [const] Allocator + [const] Destruct> Vec<T, A> {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_confusables("push_back", "put", "append")]
-    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
-    pub fn push(&mut self, value: T)
-    {
+    pub fn push(&mut self, value: T) {
         let _ = self.push_mut(value);
     }
 
@@ -1030,9 +1027,7 @@ const impl<T, A: [const] Allocator + [const] Destruct> Vec<T, A> {
     #[inline]
     #[unstable(feature = "push_mut", issue = "135974")]
     #[must_use = "if you don't need a reference to the value, use `Vec::push` instead"]
-    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
-    pub fn push_mut(&mut self, value: T) -> &mut T
-    {
+    pub fn push_mut(&mut self, value: T) -> &mut T {
         // Inform codegen that the length does not change across grow_one().
         let len = self.len;
         // This will panic or abort if we would allocate > isize::MAX bytes