Fix errors

Author: Zoxc

compiler/rustc_data_structures/src/lib.rs

@@ -13,6 +13,7 @@
 #![deny(unsafe_op_in_unsafe_fn)]
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
 #![doc(rust_logo)]
+#![feature(alloc_layout_extra)]
 #![feature(allocator_api)]
 #![feature(array_windows)]
 #![feature(ascii_char)]

compiler/rustc_data_structures/src/sync.rs

@@ -45,16 +45,17 @@ pub use self::mode::{is_dyn_thread_safe, set_dyn_thread_safe_mode};
 pub use self::parallel::{
     join, par_for_each_in, par_map, parallel_guard, scope, try_par_for_each_in,
 };
+pub use self::table::*;
 pub use self::vec::{AppendOnlyIndexVec, AppendOnlyVec};
 pub use self::worker_local::{Registry, WorkerLocal};
 pub use crate::marker::*;
 
 mod freeze;
 mod lock;
 mod parallel;
+mod table;
 mod vec;
 mod worker_local;
-mod table;
 
 /// Keep the conditional imports together in a submodule, so that import-sorting
 /// doesn't split them up.

compiler/rustc_data_structures/src/sync/table/collect.rs

@@ -1,18 +1,19 @@
 //! An API for quiescent state based reclamation.
 
-use crate::{scopeguard::guard, util::cold_path};
-use parking_lot::Mutex;
 use std::arch::asm;
-use std::{
-    cell::Cell,
-    collections::HashMap,
-    intrinsics::unlikely,
-    marker::PhantomData,
-    mem,
-    sync::LazyLock,
-    sync::atomic::{AtomicUsize, Ordering},
-    thread::{self, ThreadId},
-};
+use std::cell::Cell;
+use std::collections::HashMap;
+use std::intrinsics::unlikely;
+use std::marker::PhantomData;
+use std::mem;
+use std::sync::LazyLock;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::thread::{self, ThreadId};
+
+use parking_lot::Mutex;
+
+use super::scopeguard::guard;
+use super::util::cold_path;
 
 mod code;
 
@@ -53,12 +54,15 @@ where
     }
 }
 
-#[thread_local]
-static DATA: Data = Data {
-    pinned: Cell::new(false),
-    registered: Cell::new(false),
-    seen_events: Cell::new(0),
-};
+thread_local! {
+    static DATA: Data = const {
+        Data {
+            pinned: Cell::new(false),
+            registered: Cell::new(false),
+            seen_events: Cell::new(0),
+        }
+    };
+}
 
 struct Data {
     pinned: Cell<bool>,
@@ -110,16 +114,12 @@ cfg_if! {
     }
 }
 
-// Never inline due to thread_local bugs
-#[inline(never)]
 fn data() -> *const Data {
-    &DATA as *const Data
+    DATA.with(|data| data as *const Data)
 }
 
-// Never inline due to thread_local bugs
-#[inline(never)]
 fn data_init() -> *const Data {
-    let data = hide(&DATA as *const Data);
+    let data = hide(DATA.with(|data| data as *const Data));
 
     {
         let data = unsafe { &*data };
@@ -149,9 +149,7 @@ pub fn pin<R>(f: impl FnOnce(Pin<'_>) -> R) -> R {
     let old_pinned = data.pinned.get();
     data.pinned.set(true);
     guard(old_pinned, |pin| data.pinned.set(*pin));
-    f(Pin {
-        _private: PhantomData,
-    })
+    f(Pin { _private: PhantomData })
 }
 
 /// Removes the current thread from the threads allowed to access lock-free data structures.

compiler/rustc_data_structures/src/sync/table/mod.rs

@@ -1,16 +1,7 @@
-//! This crate contains [SyncTable] and [SyncPushVec] which offers lock-free reads and uses
+//! This module contains [SyncTable] and [SyncPushVec] which offers lock-free reads and uses
 //! quiescent state based reclamation for which an API is available in the [collect] module.
 
-#![feature(
-    alloc_layout_extra,
-    allocator_api,
-    core_intrinsics,
-    dropck_eyepatch,
-    extend_one,
-    negative_impls,
-    thread_local
-)]
-#![allow(clippy::len_without_is_empty, clippy::type_complexity)]
+#![allow(unexpected_cfgs, clippy::len_without_is_empty, clippy::type_complexity)]
 
 #[macro_use]
 mod macros;

compiler/rustc_data_structures/src/sync/table/raw/bitmask.rs

@@ -1,6 +1,7 @@
-use super::imp::{BITMASK_MASK, BITMASK_STRIDE, BitMaskWord};
 use core::intrinsics;
 
+use super::imp::{BITMASK_MASK, BITMASK_STRIDE, BitMaskWord};
+
 /// A bit mask which contains the result of a `Match` operation on a `Group` and
 /// allows iterating through them.
 ///
@@ -39,11 +40,7 @@ impl BitMask {
     /// Returns the first set bit in the `BitMask`, if there is one.
     #[inline]
     pub fn lowest_set_bit(self) -> Option<usize> {
-        if self.0 == 0 {
-            None
-        } else {
-            Some(unsafe { self.lowest_set_bit_nonzero() })
-        }
+        if self.0 == 0 { None } else { Some(unsafe { self.lowest_set_bit_nonzero() }) }
     }
 
     /// Returns the first set bit in the `BitMask`, if there is one. The

compiler/rustc_data_structures/src/sync/table/raw/generic.rs

@@ -1,22 +1,15 @@
-use super::EMPTY;
-use super::bitmask::BitMask;
 use core::intrinsics::atomic_load_acq;
 use core::mem;
 
+use super::EMPTY;
+use super::bitmask::BitMask;
+
 // Use the native word size as the group size. Using a 64-bit group size on
 // a 32-bit architecture will just end up being more expensive because
 // shifts and multiplies will need to be emulated.
-#[cfg(any(
-    target_pointer_width = "64",
-    target_arch = "aarch64",
-    target_arch = "x86_64",
-))]
+#[cfg(any(target_pointer_width = "64", target_arch = "aarch64", target_arch = "x86_64",))]
 type GroupWord = u64;
-#[cfg(all(
-    target_pointer_width = "32",
-    not(target_arch = "aarch64"),
-    not(target_arch = "x86_64"),
-))]
+#[cfg(all(target_pointer_width = "32", not(target_arch = "aarch64"), not(target_arch = "x86_64"),))]
 type GroupWord = u32;
 
 pub type BitMaskWord = GroupWord;
@@ -57,10 +50,8 @@ impl Group {
             _align: [Group; 0],
             bytes: [u8; Group::WIDTH],
         }
-        const ALIGNED_BYTES: AlignedBytes = AlignedBytes {
-            _align: [],
-            bytes: [EMPTY; Group::WIDTH],
-        };
+        const ALIGNED_BYTES: AlignedBytes =
+            AlignedBytes { _align: [], bytes: [EMPTY; Group::WIDTH] };
         unsafe { mem::transmute(ALIGNED_BYTES) }
     };
 

compiler/rustc_data_structures/src/sync/table/raw/sse2.rs

@@ -1,12 +1,12 @@
-use super::EMPTY;
-use super::bitmask::BitMask;
 use core::arch::asm;
-use core::mem;
-
 #[cfg(target_arch = "x86")]
 use core::arch::x86;
 #[cfg(target_arch = "x86_64")]
 use core::arch::x86_64 as x86;
+use core::mem;
+
+use super::EMPTY;
+use super::bitmask::BitMask;
 
 pub type BitMaskWord = u16;
 pub const BITMASK_STRIDE: usize = 1;
@@ -36,10 +36,8 @@ impl Group {
             _align: [Group; 0],
             bytes: [u8; Group::WIDTH],
         }
-        const ALIGNED_BYTES: AlignedBytes = AlignedBytes {
-            _align: [],
-            bytes: [EMPTY; Group::WIDTH],
-        };
+        const ALIGNED_BYTES: AlignedBytes =
+            AlignedBytes { _align: [], bytes: [EMPTY; Group::WIDTH] };
         unsafe { mem::transmute(ALIGNED_BYTES) }
     };
 

compiler/rustc_data_structures/src/sync/table/sync_push_vec.rs

@@ -1,26 +1,21 @@
 //! A contiguous push-only array type with lock-free reads.
 
-use crate::{
-    collect::{self, Pin},
-    scopeguard::guard,
-};
 use core::ptr::NonNull;
+use std::alloc::{Allocator, Global, Layout, LayoutError, handle_alloc_error};
+use std::cell::UnsafeCell;
+use std::intrinsics::unlikely;
+use std::iter::FromIterator;
+use std::marker::PhantomData;
+use std::ops::{Deref, DerefMut};
+use std::ptr::slice_from_raw_parts;
+use std::sync::Arc;
+use std::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
+use std::{cmp, mem};
+
 use parking_lot::{Mutex, MutexGuard};
-use std::{
-    alloc::{Allocator, Global, Layout, LayoutError, handle_alloc_error},
-    cell::UnsafeCell,
-    intrinsics::unlikely,
-    iter::FromIterator,
-    marker::PhantomData,
-    mem,
-    ops::{Deref, DerefMut},
-    sync::atomic::{AtomicPtr, Ordering},
-};
-use std::{
-    cmp,
-    ptr::slice_from_raw_parts,
-    sync::{Arc, atomic::AtomicUsize},
-};
+
+use super::collect::{self, Pin};
+use super::scopeguard::guard;
 
 mod code;
 mod tests;
@@ -94,10 +89,7 @@ impl<T> Copy for TableRef<T> {}
 impl<T> Clone for TableRef<T> {
     #[inline]
     fn clone(&self) -> Self {
-        Self {
-            data: self.data,
-            marker: self.marker,
-        }
+        Self { data: self.data, marker: self.marker }
     }
 }
 
@@ -115,12 +107,8 @@ impl<T> TableRef<T> {
             info: TableInfo,
         }
 
-        static EMPTY: EmptyTable = EmptyTable {
-            info: TableInfo {
-                capacity: 0,
-                items: AtomicUsize::new(0),
-            },
-        };
+        static EMPTY: EmptyTable =
+            EmptyTable { info: TableInfo { capacity: 0, items: AtomicUsize::new(0) } };
 
         Self {
             data: unsafe {
@@ -149,16 +137,10 @@ impl<T> TableRef<T> {
         let info =
             unsafe { NonNull::new_unchecked(ptr.as_ptr().add(info_offset) as *mut TableInfo) };
 
-        let mut result = Self {
-            data: info,
-            marker: PhantomData,
-        };
+        let mut result = Self { data: info, marker: PhantomData };
 
         unsafe {
-            *result.info_mut() = TableInfo {
-                capacity,
-                items: AtomicUsize::new(0),
-            };
+            *result.info_mut() = TableInfo { capacity, items: AtomicUsize::new(0) };
         }
 
         result
@@ -342,13 +324,9 @@ impl<T> SyncPushVec<T> {
     pub fn with_capacity(capacity: usize) -> Self {
         Self {
             current: AtomicPtr::new(
-                if capacity > 0 {
-                    TableRef::<T>::allocate(capacity)
-                } else {
-                    TableRef::empty()
-                }
-                .data
-                .as_ptr(),
+                if capacity > 0 { TableRef::<T>::allocate(capacity) } else { TableRef::empty() }
+                    .data
+                    .as_ptr(),
             ),
             old: UnsafeCell::new(Vec::new()),
             marker: PhantomData,
@@ -389,25 +367,16 @@ impl<T> SyncPushVec<T> {
     /// Creates a [LockedWrite] handle by taking the underlying mutex that protects writes.
     #[inline]
     pub fn lock(&self) -> LockedWrite<'_, T> {
-        LockedWrite {
-            table: Write { table: self },
-            _guard: self.lock.lock(),
-        }
+        LockedWrite { table: Write { table: self }, _guard: self.lock.lock() }
     }
 
     /// Creates a [LockedWrite] handle from a guard protecting the underlying mutex that protects writes.
     #[inline]
     pub fn lock_from_guard<'a>(&'a self, guard: MutexGuard<'a, ()>) -> LockedWrite<'a, T> {
         // Verify that we are target of the guard
-        assert_eq!(
-            &self.lock as *const _,
-            MutexGuard::mutex(&guard) as *const _
-        );
-
-        LockedWrite {
-            table: Write { table: self },
-            _guard: guard,
-        }
+        assert_eq!(&self.lock as *const _, MutexGuard::mutex(&guard) as *const _);
+
+        LockedWrite { table: Write { table: self }, _guard: guard }
     }
 
     /// Extracts a mutable slice of the entire vector.
@@ -545,14 +514,9 @@ impl<T: Send> Write<'_, T> {
     fn replace_table(&mut self, new_table: TableRef<T>) {
         let table = self.table.current();
 
-        self.table
-            .current
-            .store(new_table.data.as_ptr(), Ordering::Release);
+        self.table.current.store(new_table.data.as_ptr(), Ordering::Release);
 
-        let destroy = Arc::new(DestroyTable {
-            table,
-            lock: Mutex::new(false),
-        });
+        let destroy = Arc::new(DestroyTable { table, lock: Mutex::new(false) });
 
         unsafe {
             (*self.table.old.get()).push(destroy.clone());

compiler/rustc_data_structures/src/sync/table/sync_push_vec/tests.rs

@@ -8,15 +8,7 @@ fn test_iter() {
     let mut m = SyncPushVec::new();
     m.write().push(1);
     m.write().push(2);
-    assert_eq!(
-        m.write()
-            .read()
-            .as_slice()
-            .iter()
-            .copied()
-            .collect::<Vec<i32>>(),
-        vec![1, 2]
-    );
+    assert_eq!(m.write().read().as_slice().iter().copied().collect::<Vec<i32>>(), vec![1, 2]);
 }
 
 #[test]