Use ast node instead of boolean

Author: ariagivens

Cargo.lock

@@ -4010,6 +4010,7 @@ dependencies = [
 name = "rustc_feature"
 version = "0.0.0"
 dependencies = [
+ "rustc_ast",
  "rustc_data_structures",
  "rustc_hir",
  "rustc_span",

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -329,7 +329,7 @@ pub fn parse_cfg_attr(
                 Err(e) => {
                     let suggestions = CFG_ATTR_TEMPLATE.suggestions(
                         AttrSuggestionStyle::Attribute(cfg_attr.style),
-                        matches!(cfg_attr.get_normal_item().unsafety, rustc_ast::Safety::Unsafe(_)),
+                        cfg_attr.get_normal_item().unsafety,
                         sym::cfg_attr,
                     );
                     e.with_span_suggestions(
@@ -365,7 +365,7 @@ pub fn parse_cfg_attr(
                 suggestions: session_diagnostics::AttributeParseErrorSuggestions::CreatedByTemplate(
                     CFG_ATTR_TEMPLATE.suggestions(
                         AttrSuggestionStyle::Attribute(cfg_attr.style),
-                        matches!(cfg_attr.get_normal_item().unsafety, rustc_ast::Safety::Unsafe(_)),
+                        cfg_attr.get_normal_item().unsafety,
                         sym::cfg_attr,
                     ),
                 ),

compiler/rustc_attr_parsing/src/context.rs

@@ -358,7 +358,7 @@ pub struct AcceptContext<'f, 'sess> {
     pub(crate) template: &'f AttributeTemplate,
 
     /// The safety attribute (if any) applied to the attribute.
-    pub(crate) attr_safety: rustc_ast::Safety,
+    pub(crate) attr_safety: Safety,
 
     /// The name of the attribute we're currently accepting.
     pub(crate) attr_path: AttrPath,
@@ -876,11 +876,7 @@ impl<'a, 'f, 'sess: 'f> AttributeDiagnosticContext<'a, 'f, 'sess> {
             ParsedDescription::Macro => AttrSuggestionStyle::Macro,
         };
 
-        self.template.suggestions(
-            style,
-            matches!(self.attr_safety, rustc_ast::Safety::Unsafe(_)),
-            &self.attr_path,
-        )
+        self.template.suggestions(style, self.attr_safety, &self.attr_path)
     }
 }
 
@@ -1071,11 +1067,7 @@ impl<'a, 'f, 'sess: 'f> AttributeDiagnosticContext<'a, 'f, 'sess> {
             ParsedDescription::Macro => AttrSuggestionStyle::Macro,
         };
 
-        self.template.suggestions(
-            style,
-            matches!(self.attr_safety, Safety::Unsafe(_)),
-            &self.attr_path,
-        )
+        self.template.suggestions(style, self.attr_safety, &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_feature/Cargo.toml

@@ -5,6 +5,7 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
+rustc_ast = { path = "../rustc_ast" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_hir = { path = "../rustc_hir" }
 rustc_span = { path = "../rustc_span" }

compiler/rustc_feature/src/builtin_attrs.rs

@@ -3,6 +3,7 @@
 use std::sync::LazyLock;
 
 use AttributeGate::*;
+use rustc_ast::ast::Safety;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::AttrStyle;
 use rustc_span::{Symbol, sym};
@@ -118,7 +119,7 @@ impl AttributeTemplate {
     pub fn suggestions(
         &self,
         style: AttrSuggestionStyle,
-        wrap_with_unsafe: bool,
+        safety: Safety,
         name: impl std::fmt::Display,
     ) -> Vec<String> {
         let (start, macro_call, end) = match style {
@@ -130,29 +131,32 @@ impl AttributeTemplate {
 
         let mut suggestions = vec![];
 
-        let (maybe_unsafe_start, maybe_unsafe_end) =
-            if wrap_with_unsafe { ("unsafe(", ")") } else { ("", "") };
+        let (safety_start, safety_end) = match safety {
+            Safety::Unsafe(_) => ("unsafe(", ")"),
+            _ => ("", ""),
+        };
 
         if self.word {
             debug_assert!(macro_call.is_empty(), "Macro suggestions use list style");
-            suggestions.push(format!("{start}{maybe_unsafe_start}{name}{maybe_unsafe_end}{end}"));
+            suggestions.push(format!("{start}{safety_start}{name}{safety_end}{end}"));
         }
         if let Some(descr) = self.list {
             for descr in descr {
                 suggestions.push(format!(
-                    "{start}{maybe_unsafe_start}{name}{macro_call}({descr}){maybe_unsafe_end}{end}"
+                    "{start}{safety_start}{name}{macro_call}({descr}){safety_end}{end}"
                 ));
             }
         }
-        suggestions.extend(self.one_of.iter().map(|&word| {
-            format!("{start}{maybe_unsafe_start}{name}({word}){maybe_unsafe_end}{end}")
-        }));
+        suggestions.extend(
+            self.one_of
+                .iter()
+                .map(|&word| format!("{start}{safety_start}{name}({word}){safety_end}{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}{maybe_unsafe_start}{name} = \"{descr}\"{maybe_unsafe_end}{end}"
-                ));
+                suggestions
+                    .push(format!("{start}{safety_start}{name} = \"{descr}\"{safety_end}{end}"));
             }
         }
         suggestions.sort();