Auto merge of rust-lang#152382 - jhpratt:rollup-DIUVWuF, r=jhpratt

Rollup of 3 pull requests

Successful merges:

 - rust-lang#152357 (std: Don't panic when removing a nonexistent UEFI var)
 - rust-lang#152180 (Port `rustc_reservation_impl` to the new attribute parser)
 - rust-lang#152276 (Add message format checking)

Author: bors

compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs

@@ -873,3 +873,29 @@ impl<S: Stage> NoArgsAttributeParser<S> for RustcStrictCoherenceParser {
     ]);
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::RustcStrictCoherence;
 }
+
+pub(crate) struct RustcReservationImplParser;
+
+impl<S: Stage> SingleAttributeParser<S> for RustcReservationImplParser {
+    const PATH: &[Symbol] = &[sym::rustc_reservation_impl];
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const ALLOWED_TARGETS: AllowedTargets =
+        AllowedTargets::AllowList(&[Allow(Target::Impl { of_trait: true })]);
+
+    const TEMPLATE: AttributeTemplate = template!(NameValueStr: "reservation message");
+
+    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
+        let Some(nv) = args.name_value() else {
+            cx.expected_name_value(args.span().unwrap_or(cx.attr_span), None);
+            return None;
+        };
+
+        let Some(value_str) = nv.value_as_str() else {
+            cx.expected_string_literal(nv.value_span, Some(nv.value_as_lit()));
+            return None;
+        };
+
+        Some(AttributeKind::RustcReservationImpl(cx.attr_span, value_str))
+    }
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -209,6 +209,7 @@ attribute_parsers!(
         Single<RustcLintOptDenyFieldAccessParser>,
         Single<RustcMustImplementOneOfParser>,
         Single<RustcObjectLifetimeDefaultParser>,
+        Single<RustcReservationImplParser>,
         Single<RustcScalableVectorParser>,
         Single<RustcSimdMonomorphizeLaneLimitParser>,
         Single<RustcSymbolName>,

compiler/rustc_const_eval/src/errors.rs

@@ -106,9 +106,9 @@ pub(crate) struct UnstableInStableExposed {
     pub is_function_call2: bool,
     #[suggestion(
         "if the {$is_function_call2 ->
-    [true] caller
-    *[false] function
-} is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`",
+            [true] caller
+            *[false] function
+        } is not (yet) meant to be exposed to stable const contexts, add `#[rustc_const_unstable]`",
         code = "#[rustc_const_unstable(feature = \"...\", issue = \"...\")]\n",
         applicability = "has-placeholders"
     )]
@@ -300,11 +300,11 @@ pub(crate) struct UnallowedHeapAllocations {
     #[primary_span]
     #[label(
         r#"allocation not allowed in {$kind ->
-    [const] constant
-    [static] static
-    [const_fn] constant function
-    *[other] {""}
-}s"#
+            [const] constant
+            [static] static
+            [const_fn] constant function
+            *[other] {""}
+        }s"#
     )]
     pub span: Span,
     pub kind: ConstContext,
@@ -539,20 +539,20 @@ pub enum NonConstClosureNote {
     },
     #[note(
         r#"function pointers need an RFC before allowed to be called in {$kind ->
-    [const] constant
-    [static] static
-    [const_fn] constant function
-    *[other] {""}
-}s"#
+            [const] constant
+            [static] static
+            [const_fn] constant function
+            *[other] {""}
+        }s"#
     )]
     FnPtr,
     #[note(
         r#"closures need an RFC before allowed to be called in {$kind ->
-    [const] constant
-    [static] static
-    [const_fn] constant function
-    *[other] {""}
-}s"#
+            [const] constant
+            [static] static
+            [const_fn] constant function
+            *[other] {""}
+        }s"#
     )]
     Closure,
 }
@@ -608,11 +608,11 @@ pub struct LiveDrop<'tcx> {
     #[primary_span]
     #[label(
         r#"the destructor for this type cannot be evaluated in {$kind ->
-    [const] constant
-    [static] static
-    [const_fn] constant function
-    *[other] {""}
-}s"#
+            [const] constant
+            [static] static
+            [const_fn] constant function
+            *[other] {""}
+        }s"#
     )]
     pub span: Span,
     pub kind: ConstContext,

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -1219,6 +1219,9 @@ pub enum AttributeKind {
     /// Represents `#[rustc_regions]`
     RustcRegions,
 
+    /// Represents `#[rustc_reservation_impl]`
+    RustcReservationImpl(Span, Symbol),
+
     /// Represents `#[rustc_scalable_vector(N)]`
     RustcScalableVector {
         /// The base multiple of lanes that are in a scalable vector, if provided. `element_count`

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -151,6 +151,7 @@ impl AttributeKind {
             RustcPubTransparent(..) => Yes,
             RustcReallocator => No,
             RustcRegions => No,
+            RustcReservationImpl(..) => Yes,
             RustcScalableVector { .. } => Yes,
             RustcShouldNotBeCalledOnConstItems(..) => Yes,
             RustcSimdMonomorphizeLaneLimit(..) => Yes, // Affects layout computation, which needs to work cross-crate

compiler/rustc_hir_analysis/src/collect.rs

@@ -1275,7 +1275,8 @@ fn impl_trait_header(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::ImplTraitHeader
         .of_trait
         .unwrap_or_else(|| panic!("expected impl trait, found inherent impl on {def_id:?}"));
     let selfty = tcx.type_of(def_id).instantiate_identity();
-    let is_rustc_reservation = tcx.has_attr(def_id, sym::rustc_reservation_impl);
+    let is_rustc_reservation =
+        find_attr!(tcx.get_all_attrs(def_id), AttributeKind::RustcReservationImpl(..));
 
     check_impl_constness(tcx, impl_.constness, &of_trait.trait_ref);
 

compiler/rustc_macros/src/diagnostics/diagnostic_builder.rs

@@ -203,8 +203,11 @@ impl DiagnosticDeriveVariantBuilder {
                         )
                         .emit();
                     }
-                    self.message =
-                        Some(Message { message_span: message.span(), value: message.value() });
+                    self.message = Some(Message {
+                        attr_span: attr.span(),
+                        message_span: message.span(),
+                        value: message.value(),
+                    });
                 }
 
                 // Parse arguments

compiler/rustc_macros/src/diagnostics/message.rs

@@ -9,6 +9,7 @@ use crate::diagnostics::error::span_err;
 
 #[derive(Clone)]
 pub(crate) struct Message {
+    pub attr_span: Span,
     pub message_span: Span,
     pub value: String,
 }
@@ -19,12 +20,18 @@ impl Message {
     /// For subdiagnostics, we cannot check this.
     pub(crate) fn diag_message(&self, variant: Option<&VariantInfo<'_>>) -> TokenStream {
         let message = &self.value;
-        verify_fluent_message(self.message_span, &message, variant);
+        self.verify(variant);
         quote! { rustc_errors::DiagMessage::Inline(std::borrow::Cow::Borrowed(#message)) }
     }
+
+    fn verify(&self, variant: Option<&VariantInfo<'_>>) {
+        verify_variables_used(self.message_span, &self.value, variant);
+        verify_message_style(self.message_span, &self.value);
+        verify_message_formatting(self.attr_span, self.message_span, &self.value);
+    }
 }
 
-fn verify_fluent_message(msg_span: Span, message_str: &str, variant: Option<&VariantInfo<'_>>) {
+fn verify_variables_used(msg_span: Span, message_str: &str, variant: Option<&VariantInfo<'_>>) {
     // Parse the fluent message
     const GENERATED_MSG_ID: &str = "generated_msg";
     let resource =
@@ -53,8 +60,6 @@ fn verify_fluent_message(msg_span: Span, message_str: &str, variant: Option<&Var
             }
         }
     }
-
-    verify_message_style(msg_span, message_str);
 }
 
 fn variable_references<'a>(msg: &fluent_syntax::ast::Message<&'a str>) -> Vec<&'a str> {
@@ -120,3 +125,29 @@ fn verify_message_style(msg_span: Span, message: &str) {
         return;
     }
 }
+
+/// Verifies that the message is properly indented into the code
+fn verify_message_formatting(attr_span: Span, msg_span: Span, message: &str) {
+    // Find the indent at the start of the message (`column()` is one-indexed)
+    let start = attr_span.unwrap().column() - 1;
+
+    for line in message.lines().skip(1) {
+        if line.is_empty() {
+            continue;
+        }
+        let indent = line.chars().take_while(|c| *c == ' ').count();
+        if indent < start {
+            span_err(
+                msg_span.unwrap(),
+                format!("message is not properly indented. {indent} < {start}"),
+            )
+            .emit();
+            return;
+        }
+        if indent % 4 != 0 {
+            span_err(msg_span.unwrap(), "message is not indented with a multiple of 4 spaces")
+                .emit();
+            return;
+        }
+    }
+}

compiler/rustc_macros/src/diagnostics/utils.rs

@@ -708,7 +708,7 @@ impl SubdiagnosticVariant {
                     }
                     if !input.is_empty() { input.parse::<Token![,]>()?; }
                     if is_first {
-                        message = Some(Message { message_span: inline_message.span(), value: inline_message.value() });
+                        message = Some(Message { attr_span: attr.span(), message_span: inline_message.span(), value: inline_message.value() });
                         is_first = false;
                     } else {
                         span_err(inline_message.span().unwrap(), "a diagnostic message must be the first argument to the attribute").emit();

compiler/rustc_mir_build/src/errors.rs

@@ -198,12 +198,12 @@ pub(crate) struct UnsafeOpInUnsafeFnCallToFunctionWithRequiresUnsafe {
     pub(crate) missing_target_features: DiagArgValue,
     pub(crate) missing_target_features_count: usize,
     #[note("the {$build_target_features} target {$build_target_features_count ->
-    [1] feature
-    *[count] features
+        [1] feature
+        *[count] features
     } being enabled in the build configuration does not remove the requirement to list {$build_target_features_count ->
-    [1] it
-*[count] them
-} in `#[target_feature]`")]
+        [1] it
+        *[count] them
+    } in `#[target_feature]`")]
     pub(crate) note: bool,
     pub(crate) build_target_features: DiagArgValue,
     pub(crate) build_target_features_count: usize,
@@ -532,12 +532,12 @@ pub(crate) struct CallToFunctionWithRequiresUnsafe {
     pub(crate) missing_target_features: DiagArgValue,
     pub(crate) missing_target_features_count: usize,
     #[note("the {$build_target_features} target {$build_target_features_count ->
-    [1] feature
-    *[count] features
-} being enabled in the build configuration does not remove the requirement to list {$build_target_features_count ->
-    [1] it
-    *[count] them
-} in `#[target_feature]`")]
+        [1] feature
+        *[count] features
+    } being enabled in the build configuration does not remove the requirement to list {$build_target_features_count ->
+        [1] it
+        *[count] them
+    } in `#[target_feature]`")]
     pub(crate) note: bool,
     pub(crate) build_target_features: DiagArgValue,
     pub(crate) build_target_features_count: usize,
@@ -1264,9 +1264,9 @@ pub(crate) struct InterpretedAsConstSugg {
 pub(crate) enum SuggestLet {
     #[multipart_suggestion(
         "you might want to use `if let` to ignore the {$count ->
-[one] variant that isn't
-*[other] variants that aren't
-} matched",
+            [one] variant that isn't
+            *[other] variants that aren't
+        } matched",
         applicability = "has-placeholders"
     )]
     If {
@@ -1278,9 +1278,9 @@ pub(crate) enum SuggestLet {
     },
     #[suggestion(
         "you might want to use `let...else` to handle the {$count ->
-[one] variant that isn't
-*[other] variants that aren't
-} matched",
+            [one] variant that isn't
+            *[other] variants that aren't
+        } matched",
         code = " else {{ todo!() }}",
         applicability = "has-placeholders"
     )]