Auto merge of #155324 - jhpratt:rollup-BNB8Pcb, r=jhpratt

Rollup of 13 pull requests

Successful merges:

 - #154882 (Gate tuple const params behind `min_adt_const_params` feature)
 - #155259 (explicit-tail-calls: disable two tests on LoongArch)
 - #155293 (fix arch names in cfg pretty printer)
 - #155314 (`BorrowedBuf`: Update outdated safety comments in `set_init` users.)
 - #153469 (docs: clarify path search behavior in std::process::Command::new)
 - #154765 (Clarify ascii whitespace exclusion of vertical tab in the doc)
 - #155172 (Some small nits for supertrait_item_shadowing, and additional testing)
 - #155279 (Test/lexer unicode pattern white space)
 - #155280 (Tests for precise-capture through RPIT and TAIT)
 - #155301 (Delete unused `rustc_trait_selection` errors.)
 - #155303 (remove ibraheemdev from review rotation)
 - #155304 (remove PointeeParser)
 - #155319 (Remove dead diagnostic structs.)

Author: bors

compiler/rustc_attr_parsing/src/attributes/traits.rs

@@ -4,8 +4,8 @@ use super::prelude::*;
 use crate::attributes::{NoArgsAttributeParser, OnDuplicate, SingleAttributeParser};
 use crate::context::{AcceptContext, Stage};
 use crate::parser::ArgParser;
+use crate::target_checking::AllowedTargets;
 use crate::target_checking::Policy::{Allow, Warn};
-use crate::target_checking::{ALL_TARGETS, AllowedTargets};
 
 pub(crate) struct RustcSkipDuringMethodDispatchParser;
 impl<S: Stage> SingleAttributeParser<S> for RustcSkipDuringMethodDispatchParser {
@@ -141,11 +141,3 @@ impl<S: Stage> NoArgsAttributeParser<S> for FundamentalParser {
         AllowedTargets::AllowList(&[Allow(Target::Struct), Allow(Target::Trait)]);
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::Fundamental;
 }
-
-pub(crate) struct PointeeParser;
-impl<S: Stage> NoArgsAttributeParser<S> for PointeeParser {
-    const PATH: &[Symbol] = &[sym::pointee];
-    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS); //FIXME Still checked fully in `check_attr.rs`
-    const CREATE: fn(Span) -> AttributeKind = AttributeKind::Pointee;
-}

compiler/rustc_attr_parsing/src/context.rs

@@ -269,7 +269,6 @@ attribute_parsers!(
         Single<WithoutArgs<PanicHandlerParser>>,
         Single<WithoutArgs<PanicRuntimeParser>>,
         Single<WithoutArgs<PinV2Parser>>,
-        Single<WithoutArgs<PointeeParser>>,
         Single<WithoutArgs<PreludeImportParser>>,
         Single<WithoutArgs<ProcMacroAttributeParser>>,
         Single<WithoutArgs<ProcMacroParser>>,

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -1233,9 +1233,6 @@ pub enum AttributeKind {
     /// Represents `#[pin_v2]`
     PinV2(Span),
 
-    /// Represents `#[pointee]`
-    Pointee(Span),
-
     /// Represents `#[prelude_import]`
     PreludeImport,
 

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -86,7 +86,6 @@ impl AttributeKind {
             Path(..) => No,
             PatternComplexityLimit { .. } => No,
             PinV2(..) => Yes,
-            Pointee(..) => No,
             PreludeImport => No,
             ProcMacro(..) => No,
             ProcMacroAttribute(..) => No,

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -904,7 +904,7 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &ty::GenericParamDef) -> Result<(), Er
                     ) => None,
                     Err(ConstParamTyImplementationError::UnsizedConstParamsFeatureRequired) => {
                         Some(vec![
-                            (adt_const_params_feature_string, sym::adt_const_params),
+                            (adt_const_params_feature_string, sym::min_adt_const_params),
                             (
                                 " references to implement the `ConstParamTy` trait".into(),
                                 sym::unsized_const_params,
@@ -931,11 +931,13 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &ty::GenericParamDef) -> Result<(), Er
 
                         ty_is_local(ty).then_some(vec![(
                             adt_const_params_feature_string,
-                            sym::adt_const_params,
+                            sym::min_adt_const_params,
                         )])
                     }
                     // Implements `ConstParamTy`, suggest adding the feature to enable.
-                    Ok(..) => Some(vec![(adt_const_params_feature_string, sym::adt_const_params)]),
+                    Ok(..) => {
+                        Some(vec![(adt_const_params_feature_string, sym::min_adt_const_params)])
+                    }
                 };
                 if let Some(features) = may_suggest_feature {
                     tcx.disabled_nightly_features(&mut diag, features);

compiler/rustc_hir_typeck/src/method/probe.rs

@@ -2377,8 +2377,8 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
                     continue;
                 }
 
-                // This pick is not a supertrait of the `child_pick`.
-                // Check if it's a subtrait of the `child_pick`, instead.
+                // This candidate is not a supertrait of the `child_trait`.
+                // Check if it's a subtrait of the `child_trait`, instead.
                 // If it is, then it must have been a subtrait of every
                 // other pick we've eliminated at this point. It will
                 // take over at this point.
@@ -2392,7 +2392,8 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
                     continue;
                 }
 
-                // `child_pick` is not a supertrait of this pick.
+                // Neither `child_trait` or the current candidate are
+                // supertraits of each other.
                 // Don't bail here, since we may be comparing two supertraits
                 // of a common subtrait. These two supertraits won't be related
                 // at all, but we will pick them up next round when we find their

compiler/rustc_metadata/src/errors.rs

@@ -233,16 +233,6 @@ pub struct ConflictingAllocErrorHandler {
 )]
 pub struct GlobalAllocRequired;
 
-#[derive(Diagnostic)]
-#[diag(
-    "the crate `{$crate_name}` cannot depend on a crate that needs {$needs_crate_name}, but it depends on `{$deps_crate_name}`"
-)]
-pub struct NoTransitiveNeedsDep<'a> {
-    pub crate_name: Symbol,
-    pub needs_crate_name: &'a str,
-    pub deps_crate_name: Symbol,
-}
-
 #[derive(Diagnostic)]
 #[diag("failed to write {$filename}: {$err}")]
 pub struct FailedWriteError {

compiler/rustc_middle/src/error.rs

@@ -36,21 +36,6 @@ pub(crate) struct OpaqueHiddenTypeMismatch<'tcx> {
     pub sub: TypeMismatchReason,
 }
 
-#[derive(Diagnostic)]
-#[diag("we don't support unions yet: '{$ty_name}'")]
-pub struct UnsupportedUnion {
-    pub ty_name: String,
-}
-
-// FIXME(autodiff): I should get used somewhere
-#[derive(Diagnostic)]
-#[diag("reading from a `Duplicated` const {$ty} is unsafe")]
-pub struct AutodiffUnsafeInnerConstRef<'tcx> {
-    #[primary_span]
-    pub span: Span,
-    pub ty: Ty<'tcx>,
-}
-
 #[derive(Subdiagnostic)]
 pub enum TypeMismatchReason {
     #[label("this expression supplies two conflicting concrete types for the same opaque type")]

compiler/rustc_passes/src/check_attr.rs

@@ -281,7 +281,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::Path(..)
                     | AttributeKind::PatternComplexityLimit { .. }
                     | AttributeKind::PinV2(..)
-                    | AttributeKind::Pointee(..)
                     | AttributeKind::PreludeImport
                     | AttributeKind::ProfilerRuntime
                     | AttributeKind::RecursionLimit { .. }

compiler/rustc_trait_selection/src/errors.rs

@@ -28,15 +28,6 @@ pub struct UnableToConstructConstantValue<'a> {
     pub unevaluated: ty::UnevaluatedConst<'a>,
 }
 
-#[derive(Diagnostic)]
-#[diag("this attribute must have a value", code = E0232)]
-#[note("e.g. `#[rustc_on_unimplemented(message=\"foo\")]`")]
-pub struct NoValueInOnUnimplemented {
-    #[primary_span]
-    #[label("expected value here")]
-    pub span: Span,
-}
-
 pub struct NegativePositiveConflict<'tcx> {
     pub impl_span: Span,
     pub trait_desc: ty::TraitRef<'tcx>,
@@ -1201,60 +1192,6 @@ pub struct TraitImplDiff {
     pub found: String,
 }
 
-pub struct DynTraitConstraintSuggestion {
-    pub span: Span,
-    pub ident: Ident,
-}
-
-impl Subdiagnostic for DynTraitConstraintSuggestion {
-    fn add_to_diag<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
-        let mut multi_span: MultiSpan = vec![self.span].into();
-        multi_span.push_span_label(
-            self.span,
-            msg!("this has an implicit `'static` lifetime requirement"),
-        );
-        multi_span.push_span_label(
-            self.ident.span,
-            msg!("calling this method introduces the `impl`'s `'static` requirement"),
-        );
-        let msg = msg!("the used `impl` has a `'static` requirement");
-        diag.span_note(multi_span, msg);
-        let msg = msg!("consider relaxing the implicit `'static` requirement");
-        diag.span_suggestion_verbose(
-            self.span.shrink_to_hi(),
-            msg,
-            " + '_",
-            Applicability::MaybeIncorrect,
-        );
-    }
-}
-
-pub struct ReqIntroducedLocations {
-    pub span: MultiSpan,
-    pub spans: Vec<Span>,
-    pub fn_decl_span: Span,
-    pub cause_span: Span,
-    pub add_label: bool,
-}
-
-impl Subdiagnostic for ReqIntroducedLocations {
-    fn add_to_diag<G: EmissionGuarantee>(mut self, diag: &mut Diag<'_, G>) {
-        for sp in self.spans {
-            self.span.push_span_label(sp, msg!("`'static` requirement introduced here"));
-        }
-
-        if self.add_label {
-            self.span.push_span_label(
-                self.fn_decl_span,
-                msg!("requirement introduced by this return type"),
-            );
-        }
-        self.span.push_span_label(self.cause_span, msg!("because of this returned expression"));
-        let msg = msg!("\"`'static` lifetime requirement introduced by the return type");
-        diag.span_note(self.span, msg);
-    }
-}
-
 #[derive(Diagnostic)]
 #[diag("{$has_param_name ->
     [true] `{$param_name}`