Implement indent check

Author: JonathanBrouwer

compiler/rustc_macros/src/diagnostics/diagnostic_builder.rs

@@ -226,7 +226,8 @@ impl DiagnosticDeriveVariantBuilder {
                         )
                         .emit();
                     }
-                    self.message = Some(Message::Inline(message.span(), message.value()));
+                    self.message =
+                        Some(Message::Inline(attr.span(), message.span(), message.value()));
                 } else {
                     // Parse a slug
                     let slug = input.parse::<Path>()?;

compiler/rustc_macros/src/diagnostics/message.rs

@@ -11,7 +11,7 @@ use crate::diagnostics::error::span_err;
 #[derive(Clone)]
 pub(crate) enum Message {
     Slug(Path),
-    Inline(Span, String),
+    Inline(Span, Span, String),
 }
 
 impl Message {
@@ -23,8 +23,8 @@ impl Message {
             Message::Slug(slug) => {
                 quote! { crate::fluent_generated::#slug }
             }
-            Message::Inline(message_span, message) => {
-                verify_fluent_message(*message_span, &message, variant);
+            Message::Inline(attr_span, message_span, message) => {
+                verify_fluent_message(*attr_span, *message_span, &message, variant);
                 quote! { rustc_errors::DiagMessage::Inline(std::borrow::Cow::Borrowed(#message)) }
             }
         }
@@ -85,7 +85,18 @@ impl Message {
     }
 }
 
-fn verify_fluent_message(msg_span: Span, message_str: &str, variant: Option<&VariantInfo<'_>>) {
+fn verify_fluent_message(
+    attr_span: Span,
+    msg_span: Span,
+    message_str: &str,
+    variant: Option<&VariantInfo<'_>>,
+) {
+    verify_variables_used(msg_span, message_str, variant);
+    verify_message_style(msg_span, message_str);
+    verify_message_formatting(attr_span, msg_span, message_str);
+}
+
+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 =
@@ -114,8 +125,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> {
@@ -181,3 +190,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 {
-                        slug = Some(Message::Inline(message.span(), message.value()));
+                        slug = Some(Message::Inline(attr.span(), message.span(), message.value()));
                         is_first = false;
                     } else {
                         span_err(message.span().unwrap(), "a diagnostic message must be the first argument to the attribute").emit();