bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Remove some unnecessary aliases from rustc_data_structures::sync

Browse source 
With the removal of `cfg(parallel_compiler)`, these are always shared
references and `std::sync::OnceLock`.
This commit is contained in:
Zalathar 2025-03-03 20:17:26 +11:00
parent 5afd12239a
commit 32c5449d45
8 changed files with 23 additions and 39 deletions
Download patch file Download diff file Expand all files Collapse all files

10
compiler/rustc_data_structures/src/sync.rs
View file

@ -18,21 +18,16 @@
//!
//! | Type | Serial version | Parallel version |
//! | ----------------------- | ------------------- | ------------------------------- |
//! | `LRef<'a, T>` [^2] | `&'a mut T` | `&'a T` |
//! | | | |
//! | `Lock<T>` | `RefCell<T>` | `RefCell<T>` or |
//! | | | `parking_lot::Mutex<T>` |
//! | `RwLock<T>` | `RefCell<T>` | `parking_lot::RwLock<T>` |
//! | `MTLock<T>` [^1] | `T` | `Lock<T>` |
//! | `MTLockRef<'a, T>` [^2] | `&'a mut MTLock<T>` | `&'a MTLock<T>` |
//! | | | |
//! | `ParallelIterator` | `Iterator` | `rayon::iter::ParallelIterator` |
//!
//! [^1]: `MTLock` is similar to `Lock`, but the serial version avoids the cost
//! of a `RefCell`. This is appropriate when interior mutability is not
//! required.
//!
//! [^2]: `MTRef`, `MTLockRef` are type aliases.
use std::collections::HashMap;
use std::hash::{BuildHasher, Hash};
@ -97,7 +92,6 @@ mod mode {
// FIXME(parallel_compiler): Get rid of these aliases across the compiler.
pub use std::sync::OnceLock;
// Use portable AtomicU64 for targets without native 64-bit atomics
#[cfg(target_has_atomic = "64")]
pub use std::sync::atomic::AtomicU64;
@ -110,8 +104,6 @@ pub use parking_lot::{
#[cfg(not(target_has_atomic = "64"))]
pub use portable_atomic::AtomicU64;
pub type LRef<'a, T> = &'a T;
#[derive(Debug, Default)]
pub struct MTLock<T>(Lock<T>);
@ -148,8 +140,6 @@ use parking_lot::RwLock as InnerRwLock;
/// It is only useful when you are running in a single thread
const ERROR_CHECKING: bool = false;
pub type MTLockRef<'a, T> = LRef<'a, MTLock<T>>;
#[derive(Default)]
#[repr(align(64))]
pub struct CacheAligned<T>(pub T);