Auto merge of #152266 - jhpratt:rollup-YUfQl73, r=jhpratt

Rollup of 4 pull requests

Successful merges:

 - #148590 (Stabilize `atomic_try_update`and deprecate `fetch_update` starting 1.99.0)
 - #150522 (Stabilize new inclusive range type and iterator type)
 - #151576 (Stabilize `core::hint::cold_path`)
 - #152199 (Move `rustc_query_system::cache`.)

Author: bors

compiler/rustc_query_system/src/cache.rs compiler/rustc_middle/src/traits/cache.rscompiler/rustc_query_system/src/cache.rs renamed to compiler/rustc_middle/src/traits/cache.rs

@@ -7,23 +7,23 @@ use rustc_data_structures::sync::Lock;
 
 use crate::dep_graph::{DepContext, DepNodeIndex};
 
-pub struct Cache<Key, Value> {
+pub struct WithDepNodeCache<Key, Value> {
     hashmap: Lock<FxHashMap<Key, WithDepNode<Value>>>,
 }
 
-impl<Key: Clone, Value: Clone> Clone for Cache<Key, Value> {
+impl<Key: Clone, Value: Clone> Clone for WithDepNodeCache<Key, Value> {
     fn clone(&self) -> Self {
         Self { hashmap: Lock::new(self.hashmap.borrow().clone()) }
     }
 }
 
-impl<Key, Value> Default for Cache<Key, Value> {
+impl<Key, Value> Default for WithDepNodeCache<Key, Value> {
     fn default() -> Self {
         Self { hashmap: Default::default() }
     }
 }
 
-impl<Key: Eq + Hash, Value: Clone> Cache<Key, Value> {
+impl<Key: Eq + Hash, Value: Clone> WithDepNodeCache<Key, Value> {
     pub fn get<Tcx: DepContext>(&self, key: &Key, tcx: Tcx) -> Option<Value> {
         Some(self.hashmap.borrow().get(key)?.get(tcx))
     }

compiler/rustc_middle/src/traits/mod.rs

@@ -2,6 +2,7 @@
 //!
 //! [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/traits/resolution.html
 
+pub mod cache;
 pub mod query;
 pub mod select;
 pub mod solve;

compiler/rustc_middle/src/traits/select.rs

@@ -5,17 +5,20 @@
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir::def_id::DefId;
 use rustc_macros::{HashStable, TypeVisitable};
-use rustc_query_system::cache::Cache;
 use rustc_type_ir::solve::AliasBoundKind;
 
 use self::EvaluationResult::*;
 use super::{SelectionError, SelectionResult};
+use crate::traits::cache::WithDepNodeCache;
 use crate::ty;
 
-pub type SelectionCache<'tcx, ENV> =
-    Cache<(ENV, ty::TraitPredicate<'tcx>), SelectionResult<'tcx, SelectionCandidate<'tcx>>>;
+pub type SelectionCache<'tcx, ENV> = WithDepNodeCache<
+    (ENV, ty::TraitPredicate<'tcx>),
+    SelectionResult<'tcx, SelectionCandidate<'tcx>>,
+>;
 
-pub type EvaluationCache<'tcx, ENV> = Cache<(ENV, ty::PolyTraitPredicate<'tcx>), EvaluationResult>;
+pub type EvaluationCache<'tcx, ENV> =
+    WithDepNodeCache<(ENV, ty::PolyTraitPredicate<'tcx>), EvaluationResult>;
 
 /// The selection process begins by considering all impls, where
 /// clauses, and so forth that might resolve an obligation. Sometimes

compiler/rustc_middle/src/ty/context.rs

@@ -40,7 +40,6 @@ use rustc_hir::lang_items::LangItem;
 use rustc_hir::limit::Limit;
 use rustc_hir::{self as hir, HirId, Node, TraitCandidate, find_attr};
 use rustc_index::IndexVec;
-use rustc_query_system::cache::WithDepNode;
 use rustc_query_system::dep_graph::DepNodeIndex;
 use rustc_query_system::ich::StableHashingContext;
 use rustc_serialize::opaque::{FileEncodeResult, FileEncoder};
@@ -71,6 +70,7 @@ use crate::query::plumbing::QuerySystem;
 use crate::query::{IntoQueryParam, LocalCrate, Providers, TyCtxtAt};
 use crate::thir::Thir;
 use crate::traits;
+use crate::traits::cache::WithDepNode;
 use crate::traits::solve::{
     self, CanonicalInput, ExternalConstraints, ExternalConstraintsData, PredefinedOpaques,
     QueryResult, inspect,

compiler/rustc_query_system/src/lib.rs

@@ -5,7 +5,6 @@
 #![feature(min_specialization)]
 // tidy-alphabetical-end
 
-pub mod cache;
 pub mod dep_graph;
 mod error;
 pub mod ich;

library/alloc/src/sync.rs

@@ -3270,7 +3270,7 @@ impl<T: ?Sized, A: Allocator> Weak<T, A> {
         // Acquire is necessary for the success case to synchronise with `Arc::new_cyclic`, when the inner
         // value can be initialized after `Weak` references have already been created. In that case, we
         // expect to observe the fully initialized value.
-        if self.inner()?.strong.fetch_update(Acquire, Relaxed, checked_increment).is_ok() {
+        if self.inner()?.strong.try_update(Acquire, Relaxed, checked_increment).is_ok() {
             // SAFETY: pointer is not null, verified in checked_increment
             unsafe { Some(Arc::from_inner_in(self.ptr, self.alloc.clone())) }
         } else {

library/core/src/alloc/global.rs

@@ -57,7 +57,7 @@ use crate::{cmp, ptr};
 ///         let mut allocated = 0;
 ///         if self
 ///             .remaining
-///             .fetch_update(Relaxed, Relaxed, |mut remaining| {
+///             .try_update(Relaxed, Relaxed, |mut remaining| {
 ///                 if size > remaining {
 ///                     return None;
 ///                 }

library/core/src/hint.rs

@@ -724,7 +724,6 @@ pub const fn unlikely(b: bool) -> bool {
 /// # Examples
 ///
 /// ```
-/// #![feature(cold_path)]
 /// use core::hint::cold_path;
 ///
 /// fn foo(x: &[i32]) {
@@ -750,7 +749,6 @@ pub const fn unlikely(b: bool) -> bool {
 /// than the branch:
 ///
 /// ```
-/// #![feature(cold_path)]
 /// use core::hint::cold_path;
 ///
 /// #[inline(always)]
@@ -777,7 +775,8 @@ pub const fn unlikely(b: bool) -> bool {
 ///     }
 /// }
 /// ```
-#[unstable(feature = "cold_path", issue = "136873")]
+#[stable(feature = "cold_path", since = "CURRENT_RUSTC_VERSION")]
+#[rustc_const_stable(feature = "cold_path", since = "CURRENT_RUSTC_VERSION")]
 #[inline(always)]
 pub const fn cold_path() {
     crate::intrinsics::cold_path()

library/core/src/index.rs

@@ -315,7 +315,7 @@ unsafe impl<T> SliceIndex<[T]> for Clamp<ops::RangeFrom<usize>> {
 }
 
 #[unstable(feature = "sliceindex_wrappers", issue = "146179")]
-unsafe impl<T> SliceIndex<[T]> for Clamp<range::RangeTo<usize>> {
+unsafe impl<T> SliceIndex<[T]> for Clamp<ops::RangeTo<usize>> {
     type Output = [T];
 
     fn get(self, slice: &[T]) -> Option<&Self::Output> {
@@ -408,7 +408,7 @@ unsafe impl<T> SliceIndex<[T]> for Clamp<ops::RangeToInclusive<usize>> {
 }
 
 #[unstable(feature = "sliceindex_wrappers", issue = "146179")]
-unsafe impl<T> SliceIndex<[T]> for Clamp<range::RangeFull> {
+unsafe impl<T> SliceIndex<[T]> for Clamp<ops::RangeFull> {
     type Output = [T];
 
     fn get(self, slice: &[T]) -> Option<&Self::Output> {

library/core/src/intrinsics/mod.rs

@@ -409,8 +409,7 @@ pub const unsafe fn assume(b: bool) {
 /// Therefore, implementations must not require the user to uphold
 /// any safety invariants.
 ///
-/// This intrinsic does not have a stable counterpart.
-#[unstable(feature = "core_intrinsics", issue = "none")]
+/// The stabilized version of this intrinsic is [`core::hint::cold_path`].
 #[rustc_intrinsic]
 #[rustc_nounwind]
 #[miri::intrinsic_fallback_is_spec]