Auto merge of #147928 - Zalathar:rollup-2lmpajs, r=Zalathar

Rollup of 5 pull requests
Successful merges:
- #147125 (move `once` module out of `poison`)
- #147800 (Add `Cacheable` trait alias in `rustc_public_bridge`)
- #147860 (rustdoc search: relax rules for identifiers)
- #147916 (Update books)
- #147924 (rustc-dev-guide subtree update)
r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

compiler/rustc_public_bridge/src/lib.rs

@@ -21,6 +21,7 @@
 #![doc(rust_logo)]
 #![feature(rustdoc_internals)]
 #![feature(sized_hierarchy)]
+#![feature(trait_alias)]
 // tidy-alphabetical-end
 
 use std::cell::RefCell;
@@ -45,6 +46,9 @@ pub mod context;
 #[deprecated(note = "please use `rustc_public::rustc_internal` instead")]
 pubmod rustc_internal {}
 
+/// Trait alias for types that can be cached in [`Tables`].
+pubtraitCacheable = Copy + Debug + PartialEq + IndexedVal;
+
 /// A container which is used for TLS.
 pubstructContainer<'tcx,B:Bridge>{
 pubtables:RefCell<Tables<'tcx,B>>,
@@ -213,14 +217,14 @@ impl<'tcx, B: Bridge> Tables<'tcx, B> {
 /// A trait defining types that are used to emulate rustc_public components, which is really
 /// useful when programming in rustc_public-agnostic settings.
 pubtraitBridge:Sized{
-typeDefId:Copy + Debug + PartialEq + IndexedVal;
-typeAllocId:Copy + Debug + PartialEq + IndexedVal;
-typeSpan:Copy + Debug + PartialEq + IndexedVal;
-typeTy:Copy + Debug + PartialEq + IndexedVal;
-typeInstanceDef:Copy + Debug + PartialEq + IndexedVal;
-typeTyConstId:Copy + Debug + PartialEq + IndexedVal;
-typeMirConstId:Copy + Debug + PartialEq + IndexedVal;
-typeLayout:Copy + Debug + PartialEq + IndexedVal;
+typeDefId:Cacheable;
+typeAllocId:Cacheable;
+typeSpan:Cacheable;
+typeTy:Cacheable;
+typeInstanceDef:Cacheable;
+typeTyConstId:Cacheable;
+typeMirConstId:Cacheable;
+typeLayout:Cacheable;
 
 typeError:Error;
 typeCrateItem:CrateItem<Self>;
@@ -266,17 +270,15 @@ impl<K, V> Default for IndexMap<K, V> {
 }
 }
 
-impl<K:PartialEq + Hash + Eq,V:Copy + Debug + PartialEq + IndexedVal>IndexMap<K,V>{
+impl<K:PartialEq + Hash + Eq,V:Cacheable>IndexMap<K,V>{
 pubfncreate_or_fetch(&mutself,key:K) -> V{
 let len = self.index_map.len();
 let v = self.index_map.entry(key).or_insert(V::to_val(len));
 *v
 }
 }
 
-impl<K:PartialEq + Hash + Eq,V:Copy + Debug + PartialEq + IndexedVal>Index<V>
-forIndexMap<K,V>
-{
+impl<K:PartialEq + Hash + Eq,V:Cacheable>Index<V>forIndexMap<K,V>{
 typeOutput = K;
 
 fnindex(&self,index:V) -> &Self::Output{

library/std/src/sync/lazy_lock.rs

@@ -1,4 +1,4 @@
-usesuper::poison::once::ExclusiveState;
+usesuper::once::OnceExclusiveState;
 usecrate::cell::UnsafeCell;
 usecrate::mem::ManuallyDrop;
 usecrate::ops::{Deref,DerefMut};
@@ -140,14 +140,18 @@ impl<T, F: FnOnce() -> T> LazyLock<T, F> {
 pubfninto_inner(mutthis:Self) -> Result<T,F>{
 let state = this.once.state();
 match state {
-ExclusiveState::Poisoned => panic_poisoned(),
+OnceExclusiveState::Poisoned => panic_poisoned(),
  state => {
 let this = ManuallyDrop::new(this);
 let data = unsafe{ ptr::read(&this.data)}.into_inner();
 match state {
-ExclusiveState::Incomplete => Err(ManuallyDrop::into_inner(unsafe{ data.f})),
-ExclusiveState::Complete => Ok(ManuallyDrop::into_inner(unsafe{ data.value})),
-ExclusiveState::Poisoned => unreachable!(),
+OnceExclusiveState::Incomplete => {
+Err(ManuallyDrop::into_inner(unsafe{ data.f}))
+}
+OnceExclusiveState::Complete => {
+Ok(ManuallyDrop::into_inner(unsafe{ data.value}))
+}
+OnceExclusiveState::Poisoned => unreachable!(),
 }
 }
 }
@@ -189,7 +193,7 @@ impl<T, F: FnOnce() -> T> LazyLock<T, F> {
 impl<T,F>DropforPoisonOnPanic<'_,T,F>{
 #[inline]
 fndrop(&mutself){
-self.0.once.set_state(ExclusiveState::Poisoned);
+self.0.once.set_state(OnceExclusiveState::Poisoned);
 }
 }
 
@@ -200,19 +204,19 @@ impl<T, F: FnOnce() -> T> LazyLock<T, F> {
 let guard = PoisonOnPanic(this);
 let data = f();
  guard.0.data.get_mut().value = ManuallyDrop::new(data);
- guard.0.once.set_state(ExclusiveState::Complete);
+ guard.0.once.set_state(OnceExclusiveState::Complete);
  core::mem::forget(guard);
 // SAFETY: We put the value there above.
 unsafe{&mut this.data.get_mut().value}
 }
 
 let state = this.once.state();
 match state {
-ExclusiveState::Poisoned => panic_poisoned(),
+OnceExclusiveState::Poisoned => panic_poisoned(),
 // SAFETY: The `Once` states we completed the initialization.
-ExclusiveState::Complete => unsafe{&mut this.data.get_mut().value},
+OnceExclusiveState::Complete => unsafe{&mut this.data.get_mut().value},
 // SAFETY: The state is `Incomplete`.
-ExclusiveState::Incomplete => unsafe{really_init_mut(this)},
+OnceExclusiveState::Incomplete => unsafe{really_init_mut(this)},
 }
 }
 
@@ -293,7 +297,7 @@ impl<T, F> LazyLock<T, F> {
 match state {
 // SAFETY:
 // The closure has been run successfully, so `value` has been initialized.
-ExclusiveState::Complete => Some(unsafe{&mut this.data.get_mut().value}),
+OnceExclusiveState::Complete => Some(unsafe{&mut this.data.get_mut().value}),
  _ => None,
 }
 }
@@ -332,11 +336,13 @@ impl<T, F> LazyLock<T, F> {
 impl<T,F>DropforLazyLock<T,F>{
 fndrop(&mutself){
 matchself.once.state(){
-ExclusiveState::Incomplete => unsafe{ManuallyDrop::drop(&mutself.data.get_mut().f)},
-ExclusiveState::Complete => unsafe{
+OnceExclusiveState::Incomplete => unsafe{
+ManuallyDrop::drop(&mutself.data.get_mut().f)
+},
+OnceExclusiveState::Complete => unsafe{
 ManuallyDrop::drop(&mutself.data.get_mut().value)
 },
-ExclusiveState::Poisoned => {}
+OnceExclusiveState::Poisoned => {}
 }
 }
 }

library/std/src/sync/mod.rs

@@ -142,7 +142,7 @@
 //! most one thread at a time is able to access some data.
 //!
 //! - [`Once`]: Used for a thread-safe, one-time global initialization routine.
-//! Mostly useful for implementing other types like `OnceLock`.
+//! Mostly useful for implementing other types like [`OnceLock`].
 //!
 //! - [`OnceLock`]: Used for thread-safe, one-time initialization of a
 //! variable, with potentially different initializers based on the caller.
@@ -181,7 +181,24 @@ pub use alloc_crate::sync::UniqueArc;
 #[stable(feature = "rust1", since = "1.0.0")]
 pubuse alloc_crate::sync::{Arc,Weak};
 
-// FIXME(sync_nonpoison,sync_poison_mod): remove all `#[doc(inline)]` once the modules are stabilized.
+#[unstable(feature = "mpmc_channel", issue = "126840")]
+pubmod mpmc;
+pubmod mpsc;
+
+pub(crate)mod once;// `pub(crate)` for the `sys::sync::once` implementations and `LazyLock`.
+
+#[stable(feature = "rust1", since = "1.0.0")]
+pubuseself::once::{Once,OnceState};
+
+#[stable(feature = "rust1", since = "1.0.0")]
+#[doc(inline)]
+#[expect(deprecated)]
+pubuseself::once::ONCE_INIT;
+
+mod barrier;
+mod lazy_lock;
+mod once_lock;
+mod reentrant_lock;
 
 // These exist only in one flavor: no poisoning.
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -193,48 +210,37 @@ pub use self::once_lock::OnceLock;
 #[unstable(feature = "reentrant_lock", issue = "121440")]
 pubuseself::reentrant_lock::{ReentrantLock,ReentrantLockGuard};
 
-// These make sense and exist only with poisoning.
+// Note: in the future we will change the default version in `std::sync` to the non-poisoning
+// version over an edition.
+// See https://github.com/rust-lang/rust/issues/134645#issuecomment-3324577500 for more details.
+
+#[unstable(feature = "sync_nonpoison", issue = "134645")]
+pubmod nonpoison;
+#[unstable(feature = "sync_poison_mod", issue = "134646")]
+pubmod poison;
+
+// FIXME(sync_poison_mod): remove all `#[doc(inline)]` once the modules are stabilized.
+
+// These exist only with poisoning.
 #[stable(feature = "rust1", since = "1.0.0")]
 #[doc(inline)]
 pubuseself::poison::{LockResult,PoisonError};
 
-// These (should) exist in both flavors: with and without poisoning.
-// FIXME(sync_nonpoison): implement nonpoison versions:
-// * Mutex (nonpoison_mutex)
-// * Condvar (nonpoison_condvar)
-// * Once (nonpoison_once)
-// * RwLock (nonpoison_rwlock)
+// These exist in both flavors: with and without poisoning.
 // The historical default is the version with poisoning.
 #[stable(feature = "rust1", since = "1.0.0")]
 #[doc(inline)]
 pubuseself::poison::{
-Mutex,MutexGuard,TryLockError,TryLockResult,
-Condvar,
-Once,OnceState,
+TryLockError,TryLockResult,
+Mutex,MutexGuard,
 RwLock,RwLockReadGuard,RwLockWriteGuard,
+Condvar,
 };
-#[stable(feature = "rust1", since = "1.0.0")]
-#[doc(inline)]
-#[expect(deprecated)]
-pubuseself::poison::ONCE_INIT;
+
 #[unstable(feature = "mapped_lock_guards", issue = "117108")]
 #[doc(inline)]
 pubuseself::poison::{MappedMutexGuard,MappedRwLockReadGuard,MappedRwLockWriteGuard};
 
-#[unstable(feature = "mpmc_channel", issue = "126840")]
-pubmod mpmc;
-pubmod mpsc;
-
-#[unstable(feature = "sync_nonpoison", issue = "134645")]
-pubmod nonpoison;
-#[unstable(feature = "sync_poison_mod", issue = "134646")]
-pubmod poison;
-
-mod barrier;
-mod lazy_lock;
-mod once_lock;
-mod reentrant_lock;
-
 /// A type indicating whether a timed wait on a condition variable returned
 /// due to a time out or not.
 ///

library/std/src/sync/poison/once.rs library/std/src/sync/once.rslibrary/std/src/sync/poison/once.rs renamed to library/std/src/sync/once.rs

@@ -49,7 +49,9 @@ pub struct OnceState {
 pub(crate)inner: sys::OnceState,
 }
 
-pub(crate)enumExclusiveState{
+/// Used for the internal implementation of `sys::sync::once` on different platforms and the
+/// [`LazyLock`](crate::sync::LazyLock) implementation.
+pub(crate)enumOnceExclusiveState{
 Incomplete,
 Poisoned,
 Complete,
@@ -310,7 +312,7 @@ impl Once {
 /// be running, so the state must be either "incomplete", "poisoned" or
 /// "complete".
 #[inline]
-pub(crate)fnstate(&mutself) -> ExclusiveState{
+pub(crate)fnstate(&mutself) -> OnceExclusiveState{
 self.inner.state()
 }
 
@@ -320,7 +322,7 @@ impl Once {
 /// be running, so the state must be either "incomplete", "poisoned" or
 /// "complete".
 #[inline]
-pub(crate)fnset_state(&mutself,new_state:ExclusiveState){
+pub(crate)fnset_state(&mutself,new_state:OnceExclusiveState){
 self.inner.set_state(new_state);
 }
 }

library/std/src/sync/poison.rs

@@ -13,8 +13,8 @@
 //! the panics are recognized reliably or on a best-effort basis depend on the
 //! primitive. See [Overview](#overview) below.
 //!
-//! For the alternative implementations that do not employ poisoning,
-//! see [`std::sync::nonpoison`].
+//! The synchronization objects in this module have alternative implementations that do not employ
+//! poisoning in the [`std::sync::nonpoison`] module.
 //!
 //! [`std::sync::nonpoison`]: crate::sync::nonpoison
 //!
@@ -42,14 +42,6 @@
 //! [`Mutex::lock()`] returns a [`LockResult`], providing a way to deal with
 //! the poisoned state. See [`Mutex`'s documentation](Mutex#poisoning) for more.
 //!
-//! - [`Once`]: A thread-safe way to run a piece of code only once.
-//! Mostly useful for implementing one-time global initialization.
-//!
-//! [`Once`] is reliably poisoned if the piece of code passed to
-//! [`Once::call_once()`] or [`Once::call_once_force()`] panics.
-//! When in poisoned state, subsequent calls to [`Once::call_once()`] will panic too.
-//! [`Once::call_once_force()`] can be used to clear the poisoned state.
-//!
 //! - [`RwLock`]: Provides a mutual exclusion mechanism which allows
 //! multiple readers at the same time, while allowing only one
 //! writer at a time. In some cases, this can be more efficient than
@@ -59,6 +51,11 @@
 //! Note, however, that an `RwLock` may only be poisoned if a panic occurs
 //! while it is locked exclusively (write mode). If a panic occurs in any reader,
 //! then the lock will not be poisoned.
+//!
+//! Note that the [`Once`] type also employs poisoning, but since it has non-poisoning `force`
+//! methods available on it, there is no separate `nonpoison` and `poison` version.
+//!
+//! [`Once`]: crate::sync::Once
 
 // If we are not unwinding, `PoisonError` is uninhabited.
 #![cfg_attr(not(panic = "unwind"), expect(unreachable_code))]
@@ -69,11 +66,6 @@ pub use self::condvar::Condvar;
 pubuseself::mutex::MappedMutexGuard;
 #[stable(feature = "rust1", since = "1.0.0")]
 pubuseself::mutex::{Mutex,MutexGuard};
-#[stable(feature = "rust1", since = "1.0.0")]
-#[expect(deprecated)]
-pubuseself::once::ONCE_INIT;
-#[stable(feature = "rust1", since = "1.0.0")]
-pubuseself::once::{Once,OnceState};
 #[unstable(feature = "mapped_lock_guards", issue = "117108")]
 pubuseself::rwlock::{MappedRwLockReadGuard,MappedRwLockWriteGuard};
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -88,7 +80,6 @@ use crate::thread;
 mod condvar;
 #[stable(feature = "rust1", since = "1.0.0")]
 mod mutex;
-pub(crate)mod once;
 mod rwlock;
 
 pub(crate)structFlag{

library/std/src/sys/sync/once/futex.rs

@@ -1,7 +1,7 @@
 usecrate::cell::Cell;
 usecrate::sync as public;
 usecrate::sync::atomic::Ordering::{Acquire,Relaxed,Release};
-usecrate::sync::poison::once::ExclusiveState;
+usecrate::sync::once::OnceExclusiveState;
 usecrate::sys::futex::{Futex,Primitive, futex_wait, futex_wake_all};
 
 // On some platforms, the OS is very nice and handles the waiter queue for us.
@@ -83,21 +83,21 @@ impl Once {
 }
 
 #[inline]
-pub(crate)fnstate(&mutself) -> ExclusiveState{
+pub(crate)fnstate(&mutself) -> OnceExclusiveState{
 match*self.state_and_queued.get_mut(){
-INCOMPLETE => ExclusiveState::Incomplete,
-POISONED => ExclusiveState::Poisoned,
-COMPLETE => ExclusiveState::Complete,
+INCOMPLETE => OnceExclusiveState::Incomplete,
+POISONED => OnceExclusiveState::Poisoned,
+COMPLETE => OnceExclusiveState::Complete,
  _ => unreachable!("invalid Once state"),
 }
 }
 
 #[inline]
-pub(crate)fnset_state(&mutself,new_state:ExclusiveState){
+pub(crate)fnset_state(&mutself,new_state:OnceExclusiveState){
 *self.state_and_queued.get_mut() = match new_state {
-ExclusiveState::Incomplete => INCOMPLETE,
-ExclusiveState::Poisoned => POISONED,
-ExclusiveState::Complete => COMPLETE,
+OnceExclusiveState::Incomplete => INCOMPLETE,
+OnceExclusiveState::Poisoned => POISONED,
+OnceExclusiveState::Complete => COMPLETE,
 };
 }