Make attr template suggestions preserve attribute safety.

Author: obi1kenobi

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -327,8 +327,11 @@ pub fn parse_cfg_attr(
             }) {
                 Ok(r) => return Some(r),
                 Err(e) => {
-                    let suggestions = CFG_ATTR_TEMPLATE
-                        .suggestions(AttrSuggestionStyle::Attribute(cfg_attr.style), sym::cfg_attr);
+                    let suggestions = CFG_ATTR_TEMPLATE.suggestions(
+                        AttrSuggestionStyle::Attribute(cfg_attr.style),
+                        matches!(cfg_attr.get_normal_item().unsafety, rustc_ast::Safety::Unsafe(_)),
+                        sym::cfg_attr,
+                    );
                     e.with_span_suggestions(
                         cfg_attr.span,
                         "must be of the form",
@@ -360,8 +363,11 @@ pub fn parse_cfg_attr(
                 description: ParsedDescription::Attribute,
                 reason,
                 suggestions: session_diagnostics::AttributeParseErrorSuggestions::CreatedByTemplate(
-                    CFG_ATTR_TEMPLATE
-                        .suggestions(AttrSuggestionStyle::Attribute(cfg_attr.style), sym::cfg_attr),
+                    CFG_ATTR_TEMPLATE.suggestions(
+                        AttrSuggestionStyle::Attribute(cfg_attr.style),
+                        matches!(cfg_attr.get_normal_item().unsafety, rustc_ast::Safety::Unsafe(_)),
+                        sym::cfg_attr,
+                    ),
                 ),
             });
         }

compiler/rustc_attr_parsing/src/context.rs

@@ -5,7 +5,7 @@ use std::mem;
 use std::ops::{Deref, DerefMut};
 use std::sync::LazyLock;
 
-use rustc_ast::{AttrStyle, MetaItemLit};
+use rustc_ast::{AttrStyle, MetaItemLit, Safety};
 use rustc_data_structures::sync::{DynSend, DynSync};
 use rustc_errors::{Diag, DiagCtxtHandle, Diagnostic, Level, MultiSpan};
 use rustc_feature::{AttrSuggestionStyle, AttributeTemplate};
@@ -357,6 +357,9 @@ pub struct AcceptContext<'f, 'sess> {
     /// Used in reporting errors to give a hint to users what the attribute *should* look like.
     pub(crate) template: &'f AttributeTemplate,
 
+    /// The safety attribute (if any) applied to the attribute.
+    pub(crate) attr_safety: rustc_ast::Safety,
+
     /// The name of the attribute we're currently accepting.
     pub(crate) attr_path: AttrPath,
 }
@@ -873,7 +876,11 @@ impl<'a, 'f, 'sess: 'f> AttributeDiagnosticContext<'a, 'f, 'sess> {
             ParsedDescription::Macro => AttrSuggestionStyle::Macro,
         };
 
-        self.template.suggestions(style, &self.attr_path)
+        self.template.suggestions(
+            style,
+            matches!(self.attr_safety, rustc_ast::Safety::Unsafe(_)),
+            &self.attr_path,
+        )
     }
 }
 
@@ -1064,7 +1071,11 @@ impl<'a, 'f, 'sess: 'f> AttributeDiagnosticContext<'a, 'f, 'sess> {
             ParsedDescription::Macro => AttrSuggestionStyle::Macro,
         };
 
-        self.template.suggestions(style, &self.attr_path)
+        self.template.suggestions(
+            style,
+            matches!(self.attr_safety, Safety::Unsafe(_)),
+            &self.attr_path,
+        )
     }
     /// Error that a string literal was expected.
     /// You can optionally give the literal you did find (which you found not to be a string literal)

compiler/rustc_attr_parsing/src/interface.rs

@@ -234,6 +234,7 @@ impl<'sess> AttributeParser<'sess> {
             attr_style,
             parsed_description,
             template,
+            attr_safety: attr_safety.unwrap_or(Safety::Default),
             attr_path,
         };
         parse_fn(&mut cx, args)
@@ -404,6 +405,7 @@ impl<'sess> AttributeParser<'sess> {
                             attr_style: attr.style,
                             parsed_description: ParsedDescription::Attribute,
                             template: &accept.template,
+                            attr_safety: n.item.unsafety,
                             attr_path: attr_path.clone(),
                         };
 

compiler/rustc_feature/src/builtin_attrs.rs

@@ -118,6 +118,7 @@ impl AttributeTemplate {
     pub fn suggestions(
         &self,
         style: AttrSuggestionStyle,
+        wrap_with_unsafe: bool,
         name: impl std::fmt::Display,
     ) -> Vec<String> {
         let (start, macro_call, end) = match style {
@@ -129,20 +130,29 @@ impl AttributeTemplate {
 
         let mut suggestions = vec![];
 
+        let (maybe_unsafe_start, maybe_unsafe_end) =
+            if wrap_with_unsafe { ("unsafe(", ")") } else { ("", "") };
+
         if self.word {
             debug_assert!(macro_call.is_empty(), "Macro suggestions use list style");
-            suggestions.push(format!("{start}{name}{end}"));
+            suggestions.push(format!("{maybe_unsafe_start}{start}{name}{end}{maybe_unsafe_end}"));
         }
         if let Some(descr) = self.list {
             for descr in descr {
-                suggestions.push(format!("{start}{name}{macro_call}({descr}){end}"));
+                suggestions.push(format!(
+                    "{maybe_unsafe_start}{start}{name}{macro_call}({descr}){end}{maybe_unsafe_end}"
+                ));
             }
         }
-        suggestions.extend(self.one_of.iter().map(|&word| format!("{start}{name}({word}){end}")));
+        suggestions.extend(self.one_of.iter().map(|&word| {
+            format!("{maybe_unsafe_start}{start}{name}({word}){end}{maybe_unsafe_end}")
+        }));
         if let Some(descr) = self.name_value_str {
             debug_assert!(macro_call.is_empty(), "Macro suggestions use list style");
             for descr in descr {
-                suggestions.push(format!("{start}{name} = \"{descr}\"{end}"));
+                suggestions.push(format!(
+                    "{maybe_unsafe_start}{start}{name} = \"{descr}\"{end}{maybe_unsafe_end}"
+                ));
             }
         }
         suggestions.sort();