Auto merge of rust-lang#153000 - Zalathar:rollup-68jDIBK, r=Zalathar

Rollup of 9 pull requests

Successful merges:

 - rust-lang#152229 (Remove deterministic picking from query cycle handling)
 - rust-lang#152970 (extend unpin noalias tests to cover mutable references)
 - rust-lang#149783 (stabilize `cfg_select!`)
 - rust-lang#151744 (fix refining_impl_trait suggestion with return_type_notation)
 - rust-lang#152366 (Add try_shrink_to and try_shrink_to_fit to Vec)
 - rust-lang#152640 (Add direct link to rustc-dev-guide in README)
 - rust-lang#152963 (Revert "Stabilize `str_as_str`")
 - rust-lang#152984 (Remove redundant call to `check_codegen_attributes_extra` in Inliner)
 - rust-lang#152987 (Use `HashStable` derive in more places)

Author: bors

Cargo.lock

@@ -4492,7 +4492,6 @@ dependencies = [
  "rustc_abi",
  "rustc_data_structures",
  "rustc_errors",
- "rustc_hashes",
  "rustc_hir",
  "rustc_index",
  "rustc_macros",

README.md

@@ -52,6 +52,8 @@ See https://www.rust-lang.org/community for a list of chat platforms and forums.
 
 See [CONTRIBUTING.md](CONTRIBUTING.md).
 
+For a detailed explanation of the compiler's architecture and how to begin contributing, see the [rustc-dev-guide](https://rustc-dev-guide.rust-lang.org/).
+
 ## License
 
 Rust is primarily distributed under the terms of both the MIT license and the

compiler/rustc_attr_parsing/src/attributes/cfg_select.rs

@@ -128,20 +128,14 @@ pub fn parse_cfg_select(
         }
     }
 
-    if let Some(features) = features
-        && features.enabled(sym::cfg_select)
-    {
-        let it = branches
-            .reachable
-            .iter()
-            .map(|(entry, _, _)| CfgSelectPredicate::Cfg(entry.clone()))
-            .chain(branches.wildcard.as_ref().map(|(t, _, _)| CfgSelectPredicate::Wildcard(*t)))
-            .chain(
-                branches.unreachable.iter().map(|(entry, _, _)| CfgSelectPredicate::clone(entry)),
-            );
-
-        lint_unreachable(p, it, lint_node_id);
-    }
+    let it = branches
+        .reachable
+        .iter()
+        .map(|(entry, _, _)| CfgSelectPredicate::Cfg(entry.clone()))
+        .chain(branches.wildcard.as_ref().map(|(t, _, _)| CfgSelectPredicate::Wildcard(*t)))
+        .chain(branches.unreachable.iter().map(|(entry, _, _)| CfgSelectPredicate::clone(entry)));
+
+    lint_unreachable(p, it, lint_node_id);
 
     Ok(branches)
 }

compiler/rustc_codegen_cranelift/patches/0027-sysroot_tests-128bit-atomic-operations.patch

@@ -17,8 +17,8 @@ index 1e336bf..35e6f54 100644
 @@ -2,4 +2,3 @@
  // tidy-alphabetical-start
 -#![cfg_attr(target_has_atomic = "128", feature(integer_atomics))]
- #![cfg_attr(test, feature(cfg_select))]
  #![feature(array_ptr_get)]
+ #![feature(array_try_from_fn)]
 diff --git a/coretests/tests/atomic.rs b/coretests/tests/atomic.rs
 index b735957..ea728b6 100644
 --- a/coretests/tests/atomic.rs

compiler/rustc_data_structures/src/lib.rs

@@ -11,14 +11,14 @@
 #![allow(rustc::default_hash_types)]
 #![allow(rustc::potential_query_instability)]
 #![cfg_attr(bootstrap, feature(assert_matches))]
+#![cfg_attr(bootstrap, feature(cfg_select))]
 #![cfg_attr(bootstrap, feature(cold_path))]
 #![cfg_attr(test, feature(test))]
 #![deny(unsafe_op_in_unsafe_fn)]
 #![feature(allocator_api)]
 #![feature(ascii_char)]
 #![feature(ascii_char_variants)]
 #![feature(auto_traits)]
-#![feature(cfg_select)]
 #![feature(const_default)]
 #![feature(const_trait_impl)]
 #![feature(dropck_eyepatch)]
@@ -47,6 +47,9 @@ use std::fmt;
 #[cfg(not(bootstrap))]
 pub use std::{assert_matches, debug_assert_matches};
 
+// This allows derive macros to reference this crate
+extern crate self as rustc_data_structures;
+
 pub use atomic_ref::AtomicRef;
 pub use ena::{snapshot_vec, undo_log, unify};
 // Re-export `hashbrown::hash_table`, because it's part of our API

compiler/rustc_data_structures/src/sorted_map/index_map.rs

@@ -3,8 +3,7 @@
 use std::hash::{Hash, Hasher};
 
 use rustc_index::{Idx, IndexVec};
-
-use crate::stable_hasher::{HashStable, StableHasher};
+use rustc_macros::HashStable_NoContext;
 
 /// An indexed multi-map that preserves insertion order while permitting both *O*(log *n*) lookup of
 /// an item by key and *O*(1) lookup by index.
@@ -24,11 +23,13 @@ use crate::stable_hasher::{HashStable, StableHasher};
 /// in-place.
 ///
 /// [`SortedMap`]: super::SortedMap
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, HashStable_NoContext)]
 pub struct SortedIndexMultiMap<I: Idx, K, V> {
     /// The elements of the map in insertion order.
     items: IndexVec<I, (K, V)>,
 
+    // We can ignore this field because it is not observable from the outside.
+    #[stable_hasher(ignore)]
     /// Indices of the items in the set, sorted by the item's key.
     idx_sorted_by_item_key: Vec<I>,
 }
@@ -126,22 +127,6 @@ where
     }
 }
 
-impl<I: Idx, K, V, C> HashStable<C> for SortedIndexMultiMap<I, K, V>
-where
-    K: HashStable<C>,
-    V: HashStable<C>,
-{
-    fn hash_stable(&self, ctx: &mut C, hasher: &mut StableHasher) {
-        let SortedIndexMultiMap {
-            items,
-            // We can ignore this field because it is not observable from the outside.
-            idx_sorted_by_item_key: _,
-        } = self;
-
-        items.hash_stable(ctx, hasher)
-    }
-}
-
 impl<I: Idx, K: Ord, V> FromIterator<(K, V)> for SortedIndexMultiMap<I, K, V> {
     fn from_iter<J>(iter: J) -> Self
     where

compiler/rustc_data_structures/src/svh.rs

@@ -7,12 +7,21 @@
 
 use std::fmt;
 
-use rustc_macros::{Decodable_NoContext, Encodable_NoContext};
+use rustc_macros::{Decodable_NoContext, Encodable_NoContext, HashStable_NoContext};
 
 use crate::fingerprint::Fingerprint;
-use crate::stable_hasher;
 
-#[derive(Copy, Clone, PartialEq, Eq, Debug, Encodable_NoContext, Decodable_NoContext, Hash)]
+#[derive(
+    Copy,
+    Clone,
+    PartialEq,
+    Eq,
+    Debug,
+    Encodable_NoContext,
+    Decodable_NoContext,
+    Hash,
+    HashStable_NoContext
+)]
 pub struct Svh {
     hash: Fingerprint,
 }
@@ -39,11 +48,3 @@ impl fmt::Display for Svh {
         f.pad(&self.to_hex())
     }
 }
-
-impl<T> stable_hasher::HashStable<T> for Svh {
-    #[inline]
-    fn hash_stable(&self, ctx: &mut T, hasher: &mut stable_hasher::StableHasher) {
-        let Svh { hash } = *self;
-        hash.hash_stable(ctx, hasher);
-    }
-}

compiler/rustc_feature/src/accepted.rs

@@ -102,6 +102,8 @@ declare_features! (
     (accepted, cfg_doctest, "1.40.0", Some(62210)),
     /// Enables `#[cfg(panic = "...")]` config key.
     (accepted, cfg_panic, "1.60.0", Some(77443)),
+    /// Provides a native way to easily manage multiple conditional flags without having to rewrite each clause multiple times.
+    (accepted, cfg_select, "CURRENT_RUSTC_VERSION", Some(115585)),
     /// Allows `cfg(target_abi = "...")`.
     (accepted, cfg_target_abi, "1.78.0", Some(80970)),
     /// Allows `cfg(target_feature = "...")`.

compiler/rustc_feature/src/unstable.rs

@@ -388,8 +388,6 @@ declare_features! (
     (unstable, cfg_sanitize, "1.41.0", Some(39699)),
     /// Allows `cfg(sanitizer_cfi_generalize_pointers)` and `cfg(sanitizer_cfi_normalize_integers)`.
     (unstable, cfg_sanitizer_cfi, "1.77.0", Some(89653)),
-    /// Provides a native way to easily manage multiple conditional flags without having to rewrite each clause multiple times.
-    (unstable, cfg_select, "CURRENT_RUSTC_VERSION", Some(115585)),
     /// Allows `cfg(target(abi = "..."))`.
     (unstable, cfg_target_compact, "1.63.0", Some(96901)),
     /// Allows `cfg(target_has_atomic_load_store = "...")`.

compiler/rustc_hir/src/diagnostic_items.rs

@@ -1,19 +1,13 @@
 use rustc_data_structures::fx::FxIndexMap;
-use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
+use rustc_macros::HashStable_Generic;
 use rustc_span::Symbol;
 use rustc_span::def_id::DefIdMap;
 
 use crate::def_id::DefId;
 
-#[derive(Debug, Default)]
+#[derive(Debug, Default, HashStable_Generic)]
 pub struct DiagnosticItems {
+    #[stable_hasher(ignore)]
     pub id_to_name: DefIdMap<Symbol>,
     pub name_to_id: FxIndexMap<Symbol, DefId>,
 }
-
-impl<CTX: crate::HashStableContext> HashStable<CTX> for DiagnosticItems {
-    #[inline]
-    fn hash_stable(&self, ctx: &mut CTX, hasher: &mut StableHasher) {
-        self.name_to_id.hash_stable(ctx, hasher);
-    }
-}