Auto merge of #161731 - jhpratt:rollup-cUfsCoq, r=jhpratt

Rollup of 5 pull requests

Successful merges:

 - #156749 (remove `box_patterns`)
 - #161411 (avoid overlapping const suggestions)
 - #161484 (Discard `.pdr` in the PSP linker script)
 - #161663 (Reduce dependency on implicit paths in bootstrap)
 - #161720 (rename rust_target_features query to make it clear that these are *all* target features)

Author: bors

compiler/rustc_ast/src/ast.rs

@@ -686,8 +686,7 @@ impl Pat {
             | PatKind::Or(s) => s.iter().for_each(|p| p.walk(it)),
 
             // Trivial wrappers over inner patterns.
-            PatKind::Box(s)
-            | PatKind::Deref(s)
+            PatKind::Deref(s)
             | PatKind::Ref(s, _, _)
             | PatKind::Paren(s)
             | PatKind::Guard(s, _) => s.walk(it),
@@ -901,9 +900,6 @@ pub enum PatKind {
     /// A tuple pattern (`(a, b)`).
     Tuple(ThinVec<Pat>),
 
-    /// A `box` pattern.
-    Box(Box<Pat>),
-
     /// A `deref` pattern (currently `deref!()` macro-based syntax).
     Deref(Box<Pat>),
 

compiler/rustc_ast_lowering/src/pat.rs

@@ -116,9 +116,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     let (pats, ddpos) = self.lower_pat_tuple(pats, "tuple");
                     break hir::PatKind::Tuple(pats, ddpos);
                 }
-                PatKind::Box(inner) => {
-                    break hir::PatKind::Box(self.lower_pat(inner));
-                }
                 PatKind::Deref(inner) => {
                     break hir::PatKind::Deref(self.lower_pat(inner));
                 }

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -339,9 +339,6 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
                     }
                 }
             }
-            PatKind::Box(..) => {
-                gate!(self, box_patterns, pattern.span, "box pattern syntax is experimental");
-            }
             _ => {}
         }
         visit::walk_pat(self, pattern)
@@ -596,7 +593,6 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
 
     // tidy-alphabetical-start
     soft_gate_all_legacy_dont_use!(auto_traits, "`auto` traits are unstable");
-    soft_gate_all_legacy_dont_use!(box_patterns, "box pattern syntax is experimental");
     soft_gate_all_legacy_dont_use!(decl_macro, "`macro` is experimental");
     soft_gate_all_legacy_dont_use!(negative_impls, "negative impls are experimental");
     soft_gate_all_legacy_dont_use!(specialization, "specialization is experimental");

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -2011,10 +2011,6 @@ impl<'a> State<'a> {
                 }
                 self.pclose();
             }
-            PatKind::Box(inner) => {
-                self.word("box ");
-                self.print_pat_paren_if_or(inner);
-            }
             PatKind::Deref(inner) => {
                 self.word("deref!");
                 self.popen();

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -64,7 +64,7 @@ fn process_builtin_attrs(
     codegen_fn_attrs: &mut CodegenFnAttrs,
 ) -> InterestingAttributeDiagnosticSpans {
     let mut interesting_spans = InterestingAttributeDiagnosticSpans::default();
-    let rust_target_features = tcx.rust_target_features(LOCAL_CRATE);
+    let rust_target_features = tcx.all_rust_target_features(LOCAL_CRATE);
 
     let parsed_attrs = attrs
         .iter()

compiler/rustc_codegen_ssa/src/target_features.rs

@@ -528,7 +528,7 @@ pub fn sanitizer_features_by_flags(sess: &Session, features: &mut Vec<String>) {
 
 pub(crate) fn provide(providers: &mut Providers) {
     *providers = Providers {
-        rust_target_features: |tcx, cnum| {
+        all_rust_target_features: |tcx, cnum| {
             assert_eq!(cnum, LOCAL_CRATE);
             if tcx.sess.opts.actually_rustdoc {
                 // HACK: rustdoc would like to pretend that we have all the target features, so we

compiler/rustc_feature/src/removed.rs

@@ -65,6 +65,8 @@ declare_features! (
      Some("merged into `min_generic_const_args`")),
     (removed, await_macro, "1.38.0", Some(50547),
      Some("subsumed by `.await` syntax"), 62293),
+    /// Allows using `box` in patterns (RFC 469).
+    (removed, box_patterns, "CURRENT_RUSTC_VERSION", Some(29641), Some("superseded by `deref_patterns`")),
     /// Allows using the `box $expr` syntax.
     (removed, box_syntax, "1.70.0", Some(49733), Some("replaced with `#[rustc_box]`"), 108471),
     /// Allows capturing disjoint fields in a closure/coroutine (RFC 2229).

compiler/rustc_feature/src/unstable.rs

@@ -313,8 +313,6 @@ declare_features! (
     /// Allows features specific to auto traits.
     /// Renamed from `optin_builtin_traits`.
     (unstable, auto_traits, "1.50.0", Some(13231)),
-    /// Allows using `box` in patterns (RFC 469).
-    (unstable, box_patterns, "1.0.0", Some(29641)),
     /// Allows builtin # foo() syntax
     (internal, builtin_syntax, "1.71.0", Some(110680)),
     /// Allows `#[doc(notable_trait)]`.

compiler/rustc_hir/src/hir.rs

@@ -1535,9 +1535,7 @@ impl<'hir> Pat<'hir> {
         match self.kind {
             Missing => unreachable!(),
             Wild | Never | Expr(_) | Range(..) | Binding(.., None) | Err(_) => true,
-            Box(s) | Deref(s) | Ref(s, _, _) | Binding(.., Some(s)) | Guard(s, _) => {
-                s.walk_short_(it)
-            }
+            Deref(s) | Ref(s, _, _) | Binding(.., Some(s)) | Guard(s, _) => s.walk_short_(it),
             Struct(_, fields, _) => fields.iter().all(|field| field.pat.walk_short_(it)),
             TupleStruct(_, s, _) | Tuple(s, _) | Or(s) => s.iter().all(|p| p.walk_short_(it)),
             Slice(before, slice, after) => {
@@ -1564,7 +1562,7 @@ impl<'hir> Pat<'hir> {
         use PatKind::*;
         match self.kind {
             Missing | Wild | Never | Expr(_) | Range(..) | Binding(.., None) | Err(_) => {}
-            Box(s) | Deref(s) | Ref(s, _, _) | Binding(.., Some(s)) | Guard(s, _) => s.walk_(it),
+            Deref(s) | Ref(s, _, _) | Binding(.., Some(s)) | Guard(s, _) => s.walk_(it),
             Struct(_, fields, _) => fields.iter().for_each(|field| field.pat.walk_(it)),
             TupleStruct(_, s, _) | Tuple(s, _) | Or(s) => s.iter().for_each(|p| p.walk_(it)),
             Slice(before, slice, after) => {
@@ -1646,7 +1644,6 @@ impl<'hir> Pat<'hir> {
             | PatKind::Struct(_, _, _)
             | PatKind::TupleStruct(_, _, _)
             | PatKind::Tuple(_, _)
-            | PatKind::Box(_)
             | PatKind::Ref(_, _, _)
             | PatKind::Deref(_)
             | PatKind::Expr(_)
@@ -1792,9 +1789,6 @@ pub enum PatKind<'hir> {
     /// `0 <= position <= subpats.len()`
     Tuple(&'hir [Pat<'hir>], DotDotPos),
 
-    /// A `box` pattern.
-    Box(&'hir Pat<'hir>),
-
     /// A `deref` pattern (currently `deref!()` macro-based syntax).
     Deref(&'hir Pat<'hir>),
 

compiler/rustc_hir/src/intravisit.rs

@@ -746,9 +746,7 @@ pub fn walk_pat<'v, V: Visitor<'v>>(visitor: &mut V, pattern: &'v Pat<'v>) -> V:
         PatKind::Tuple(tuple_elements, _) => {
             walk_list!(visitor, visit_pat, tuple_elements);
         }
-        PatKind::Box(ref subpattern)
-        | PatKind::Deref(ref subpattern)
-        | PatKind::Ref(ref subpattern, _, _) => {
+        PatKind::Deref(ref subpattern) | PatKind::Ref(ref subpattern, _, _) => {
             try_visit!(visitor.visit_pat(subpattern));
         }
         PatKind::Binding(_, _hir_id, ident, ref optional_subpattern) => {