Auto merge of #149063 - matthiaskrgr:rollup-6z23izv, r=matthiaskrgr

Rollup of 5 pull requests
Successful merges:
- #147887 (Improve the documentation of atomic::fence)
- #148281 (repr(transparent) check: do not compute check_unsuited more than once)
- #148484 (Fix suggestion for the `cfg!` macro)
- #149057 (`rust-analyzer` subtree update)
- #149061 (debug-assert FixedSizeEncoding invariant)
r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -2,7 +2,7 @@ use rustc_ast::token::Delimiter;
 use rustc_ast::tokenstream::DelimSpan;
 use rustc_ast::{AttrItem,Attribute,CRATE_NODE_ID,LitKind,NodeId, ast, token};
 use rustc_errors::{Applicability,PResult};
-use rustc_feature::{AttributeTemplate,Features, template};
+use rustc_feature::{AttrSuggestionStyle,AttributeTemplate,Features, template};
 use rustc_hir::attrs::CfgEntry;
 use rustc_hir::{AttrPath,RustcVersion};
 use rustc_parse::parser::{ForceCollect,Parser};
@@ -323,8 +323,8 @@ pub fn parse_cfg_attr(
 }){
 Ok(r) => returnSome(r),
 Err(e) => {
-let suggestions =
-CFG_ATTR_TEMPLATE.suggestions(Some(cfg_attr.style), sym::cfg_attr);
+let suggestions =CFG_ATTR_TEMPLATE
+.suggestions(AttrSuggestionStyle::Attribute(cfg_attr.style), sym::cfg_attr);
  e.with_span_suggestions(
  cfg_attr.span,
 "must be of the form",
@@ -355,7 +355,8 @@ pub fn parse_cfg_attr(
 path:AttrPath::from_ast(&cfg_attr.get_normal_item().path),
 description:ParsedDescription::Attribute,
  reason,
-suggestions:CFG_ATTR_TEMPLATE.suggestions(Some(cfg_attr.style), sym::cfg_attr),
+suggestions:CFG_ATTR_TEMPLATE
+.suggestions(AttrSuggestionStyle::Attribute(cfg_attr.style), sym::cfg_attr),
 });
 }
 }

compiler/rustc_attr_parsing/src/context.rs

@@ -6,7 +6,7 @@ use std::sync::LazyLock;
 use private::Sealed;
 use rustc_ast::{AttrStyle,CRATE_NODE_ID,MetaItemLit,NodeId};
 use rustc_errors::{Diag,Diagnostic,Level};
-use rustc_feature::AttributeTemplate;
+use rustc_feature::{AttrSuggestionStyle,AttributeTemplate};
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::lints::{AttributeLint,AttributeLintKind};
 use rustc_hir::{AttrPath,CRATE_HIR_ID,HirId};
@@ -637,9 +637,15 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
 }
 
 pub(crate)fnsuggestions(&self) -> Vec<String>{
-// If the outer and inner spans are equal, we are parsing an attribute from `cfg_attr`,
-// So don't display an attribute style in the suggestions
-let style = (self.attr_span != self.inner_span).then_some(self.attr_style);
+let style = matchself.parsed_description{
+// If the outer and inner spans are equal, we are parsing an embedded attribute
+ParsedDescription::Attributeifself.attr_span == self.inner_span => {
+AttrSuggestionStyle::EmbeddedAttribute
+}
+ParsedDescription::Attribute => AttrSuggestionStyle::Attribute(self.attr_style),
+ParsedDescription::Macro => AttrSuggestionStyle::Macro,
+};
+
 self.template.suggestions(style,&self.attr_path)
 }
 }

compiler/rustc_feature/src/builtin_attrs.rs

@@ -132,28 +132,45 @@ pub struct AttributeTemplate {
 pubdocs:Option<&'staticstr>,
 }
 
+pubenumAttrSuggestionStyle{
+/// The suggestion is styled for a normal attribute.
+/// The `AttrStyle` determines whether this is an inner or outer attribute.
+Attribute(AttrStyle),
+/// The suggestion is styled for an attribute embedded into another attribute.
+/// For example, attributes inside `#[cfg_attr(true, attr(...)]`.
+EmbeddedAttribute,
+/// The suggestion is styled for macros that are parsed with attribute parsers.
+/// For example, the `cfg!(predicate)` macro.
+Macro,
+}
+
 implAttributeTemplate{
 pubfnsuggestions(
 &self,
-style:Option<AttrStyle>,
+style:AttrSuggestionStyle,
 name:impl std::fmt::Display,
 ) -> Vec<String>{
-letmut suggestions = vec![];
-let(start, end) =match style {
-Some(AttrStyle::Outer) => ("#[","]"),
-Some(AttrStyle::Inner) => ("#![","]"),
-None => ("",""),
+let(start, macro_call, end) = match style {
+AttrSuggestionStyle::Attribute(AttrStyle::Outer) => ("#[","","]"),
+AttrSuggestionStyle::Attribute(AttrStyle::Inner) => ("#![","","]"),
+AttrSuggestionStyle::Macro => ("","!",""),
+AttrSuggestionStyle::EmbeddedAttribute => ("","",""),
 };
+
+letmut suggestions = vec![];
+
 ifself.word{
+debug_assert!(macro_call.is_empty(),"Macro suggestions use list style");
  suggestions.push(format!("{start}{name}{end}"));
 }
 ifletSome(descr) = self.list{
 for descr in descr {
- suggestions.push(format!("{start}{name}({descr}){end}"));
+ suggestions.push(format!("{start}{name}{macro_call}({descr}){end}"));
 }
 }
  suggestions.extend(self.one_of.iter().map(|&word| format!("{start}{name}({word}){end}")));
 ifletSome(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}"));
 }

compiler/rustc_feature/src/lib.rs

@@ -129,9 +129,10 @@ pub fn find_feature_issue(feature: Symbol, issue: GateIssue) -> Option<NonZero<u
 
 pubuse accepted::ACCEPTED_LANG_FEATURES;
 pubuse builtin_attrs::{
-AttributeDuplicates,AttributeGate,AttributeSafety,AttributeTemplate,AttributeType,
-BUILTIN_ATTRIBUTE_MAP,BUILTIN_ATTRIBUTES,BuiltinAttribute,GatedCfg, encode_cross_crate,
- find_gated_cfg, is_builtin_attr_name, is_stable_diagnostic_attribute, is_valid_for_get_attr,
+AttrSuggestionStyle,AttributeDuplicates,AttributeGate,AttributeSafety,AttributeTemplate,
+AttributeType,BUILTIN_ATTRIBUTE_MAP,BUILTIN_ATTRIBUTES,BuiltinAttribute,GatedCfg,
+ encode_cross_crate, find_gated_cfg, is_builtin_attr_name, is_stable_diagnostic_attribute,
+ is_valid_for_get_attr,
 };
 pubuse removed::REMOVED_LANG_FEATURES;
 pubuse unstable::{

compiler/rustc_hir_analysis/src/check/check.rs

@@ -1542,22 +1542,10 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
 
 let typing_env = ty::TypingEnv::non_body_analysis(tcx, adt.did());
 // For each field, figure out if it has "trivial" layout (i.e., is a 1-ZST).
-// Even some 1-ZST fields are not allowed though, if they have `non_exhaustive` or private
-// fields or `repr(C)`. We call those fields "unsuited".
 structFieldInfo<'tcx>{
 span:Span,
 trivial:bool,
-unsuited:Option<UnsuitedInfo<'tcx>>,
-}
-structUnsuitedInfo<'tcx>{
-/// The source of the problem, a type that is found somewhere within the field type.
 ty:Ty<'tcx>,
-reason:UnsuitedReason,
-}
-enumUnsuitedReason{
-NonExhaustive,
-PrivateField,
-ReprC,
 }
 
 let field_infos = adt.all_fields().map(|field| {
@@ -1566,60 +1554,7 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
 // We are currently checking the type this field came from, so it must be local
 let span = tcx.hir_span_if_local(field.did).unwrap();
 let trivial = layout.is_ok_and(|layout| layout.is_1zst());
-if !trivial {
-// No need to even compute `unsuited`.
-returnFieldInfo{ span, trivial,unsuited:None};
-}
-
-fncheck_unsuited<'tcx>(
-tcx:TyCtxt<'tcx>,
-typing_env: ty::TypingEnv<'tcx>,
-ty:Ty<'tcx>,
-) -> ControlFlow<UnsuitedInfo<'tcx>>{
-// We can encounter projections during traversal, so ensure the type is normalized.
-let ty = tcx.try_normalize_erasing_regions(typing_env, ty).unwrap_or(ty);
-match ty.kind(){
- ty::Tuple(list) => list.iter().try_for_each(|t| check_unsuited(tcx, typing_env, t)),
- ty::Array(ty, _) => check_unsuited(tcx, typing_env,*ty),
- ty::Adt(def, args) => {
-if !def.did().is_local()
- && !find_attr!(
- tcx.get_all_attrs(def.did()),
-AttributeKind::PubTransparent(_)
-)
-{
-let non_exhaustive = def.is_variant_list_non_exhaustive()
- || def
-.variants()
-.iter()
-.any(ty::VariantDef::is_field_list_non_exhaustive);
-let has_priv = def.all_fields().any(|f| !f.vis.is_public());
-if non_exhaustive || has_priv {
-returnControlFlow::Break(UnsuitedInfo{
- ty,
-reason:if non_exhaustive {
-UnsuitedReason::NonExhaustive
-}else{
-UnsuitedReason::PrivateField
-},
-});
-}
-}
-if def.repr().c(){
-returnControlFlow::Break(UnsuitedInfo{
- ty,
-reason:UnsuitedReason::ReprC,
-});
-}
- def.all_fields()
-.map(|field| field.ty(tcx, args))
-.try_for_each(|t| check_unsuited(tcx, typing_env, t))
-}
- _ => ControlFlow::Continue(()),
-}
-}
-
-FieldInfo{ span, trivial,unsuited:check_unsuited(tcx, typing_env, ty).break_value()}
+FieldInfo{ span, trivial, ty }
 });
 
 let non_trivial_fields = field_infos
@@ -1637,10 +1572,63 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
 return;
 }
 
+// Even some 1-ZST fields are not allowed though, if they have `non_exhaustive` or private
+// fields or `repr(C)`. We call those fields "unsuited".
+structUnsuitedInfo<'tcx>{
+/// The source of the problem, a type that is found somewhere within the field type.
+ty:Ty<'tcx>,
+reason:UnsuitedReason,
+}
+enumUnsuitedReason{
+NonExhaustive,
+PrivateField,
+ReprC,
+}
+
+fncheck_unsuited<'tcx>(
+tcx:TyCtxt<'tcx>,
+typing_env: ty::TypingEnv<'tcx>,
+ty:Ty<'tcx>,
+) -> ControlFlow<UnsuitedInfo<'tcx>>{
+// We can encounter projections during traversal, so ensure the type is normalized.
+let ty = tcx.try_normalize_erasing_regions(typing_env, ty).unwrap_or(ty);
+match ty.kind(){
+ ty::Tuple(list) => list.iter().try_for_each(|t| check_unsuited(tcx, typing_env, t)),
+ ty::Array(ty, _) => check_unsuited(tcx, typing_env,*ty),
+ ty::Adt(def, args) => {
+if !def.did().is_local()
+ && !find_attr!(tcx.get_all_attrs(def.did()),AttributeKind::PubTransparent(_))
+{
+let non_exhaustive = def.is_variant_list_non_exhaustive()
+ || def.variants().iter().any(ty::VariantDef::is_field_list_non_exhaustive);
+let has_priv = def.all_fields().any(|f| !f.vis.is_public());
+if non_exhaustive || has_priv {
+returnControlFlow::Break(UnsuitedInfo{
+ ty,
+reason:if non_exhaustive {
+UnsuitedReason::NonExhaustive
+}else{
+UnsuitedReason::PrivateField
+},
+});
+}
+}
+if def.repr().c(){
+returnControlFlow::Break(UnsuitedInfo{ ty,reason:UnsuitedReason::ReprC});
+}
+ def.all_fields()
+.map(|field| field.ty(tcx, args))
+.try_for_each(|t| check_unsuited(tcx, typing_env, t))
+}
+ _ => ControlFlow::Continue(()),
+}
+}
+
 letmut prev_unsuited_1zst = false;
 for field in field_infos {
-ifletSome(unsuited) = field.unsuited{
-assert!(field.trivial);
+if field.trivial
+ && letSome(unsuited) = check_unsuited(tcx, typing_env, field.ty).break_value()
+{
 // If there are any non-trivial fields, then there can be no non-exhaustive 1-zsts.
 // Otherwise, it's only an issue if there's >1 non-exhaustive 1-zst.
 if non_trivial_count > 0 || prev_unsuited_1zst {

compiler/rustc_metadata/src/rmeta/table.rs

@@ -55,8 +55,10 @@ impl IsDefault for UnusedGenericParams {
 
 /// Helper trait, for encoding to, and decoding from, a fixed number of bytes.
 /// Used mainly for Lazy positions and lengths.
-/// Unchecked invariant: `Self::default()` should encode as `[0; BYTE_LEN]`,
+///
+/// Invariant: `Self::default()` should encode as `[0; BYTE_LEN]`,
 /// but this has no impact on safety.
+/// In debug builds, this invariant is checked in `[TableBuilder::set]`
 pub(super)traitFixedSizeEncoding:IsDefault{
 /// This should be `[u8; BYTE_LEN]`;
 /// Cannot use an associated `const BYTE_LEN: usize` instead due to const eval limitations.
@@ -432,6 +434,13 @@ impl<I: Idx, const N: usize, T: FixedSizeEncoding<ByteArray = [u8; N]>> TableBui
 /// arises in the future then a new method (e.g. `clear` or `reset`) will need to be introduced
 /// for doing that explicitly.
 pub(crate)fnset(&mutself,i:I,value:T){
+#[cfg(debug_assertions)]
+{
+debug_assert!(
+T::from_bytes(&[0;N]).is_default(),
+"expected all-zeroes to decode to the default value, as per the invariant of FixedSizeEncoding"
+);
+}
 if !value.is_default(){
 // FIXME(eddyb) investigate more compact encodings for sparse tables.
 // On the PR @michaelwoerister mentioned:

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -2,7 +2,7 @@ use rustc_ast::token::Delimiter;
 use rustc_ast::tokenstream::DelimSpan;
 use rustc_ast::{AttrItem,Attribute,CRATE_NODE_ID,LitKind,NodeId, ast, token};
 use rustc_errors::{Applicability,PResult};
-use rustc_feature::{AttributeTemplate,Features, template};
+use rustc_feature::{AttrSuggestionStyle,AttributeTemplate,Features, template};
 use rustc_hir::attrs::CfgEntry;
 use rustc_hir::{AttrPath,RustcVersion};
 use rustc_parse::parser::{ForceCollect,Parser};
@@ -323,8 +323,8 @@ pub fn parse_cfg_attr(
 }){
 Ok(r) => returnSome(r),
 Err(e) => {
-let suggestions =
-CFG_ATTR_TEMPLATE.suggestions(Some(cfg_attr.style), sym::cfg_attr);
+let suggestions =CFG_ATTR_TEMPLATE
+.suggestions(AttrSuggestionStyle::Attribute(cfg_attr.style), sym::cfg_attr);
  e.with_span_suggestions(
  cfg_attr.span,
 "must be of the form",
@@ -355,7 +355,8 @@ pub fn parse_cfg_attr(
 path:AttrPath::from_ast(&cfg_attr.get_normal_item().path),
 description:ParsedDescription::Attribute,
  reason,
-suggestions:CFG_ATTR_TEMPLATE.suggestions(Some(cfg_attr.style), sym::cfg_attr),
+suggestions:CFG_ATTR_TEMPLATE
+.suggestions(AttrSuggestionStyle::Attribute(cfg_attr.style), sym::cfg_attr),
 });
 }
 }

compiler/rustc_attr_parsing/src/context.rs

@@ -6,7 +6,7 @@ use std::sync::LazyLock;
 use private::Sealed;
 use rustc_ast::{AttrStyle,CRATE_NODE_ID,MetaItemLit,NodeId};
 use rustc_errors::{Diag,Diagnostic,Level};
-use rustc_feature::AttributeTemplate;
+use rustc_feature::{AttrSuggestionStyle,AttributeTemplate};
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::lints::{AttributeLint,AttributeLintKind};
 use rustc_hir::{AttrPath,CRATE_HIR_ID,HirId};
@@ -637,9 +637,15 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
 }
 
 pub(crate)fnsuggestions(&self) -> Vec<String>{
-// If the outer and inner spans are equal, we are parsing an attribute from `cfg_attr`,
-// So don't display an attribute style in the suggestions
-let style = (self.attr_span != self.inner_span).then_some(self.attr_style);
+let style = matchself.parsed_description{
+// If the outer and inner spans are equal, we are parsing an embedded attribute
+ParsedDescription::Attributeifself.attr_span == self.inner_span => {
+AttrSuggestionStyle::EmbeddedAttribute
+}
+ParsedDescription::Attribute => AttrSuggestionStyle::Attribute(self.attr_style),
+ParsedDescription::Macro => AttrSuggestionStyle::Macro,
+};
+
 self.template.suggestions(style,&self.attr_path)
 }
 }

compiler/rustc_feature/src/builtin_attrs.rs

@@ -132,28 +132,45 @@ pub struct AttributeTemplate {
 pubdocs:Option<&'staticstr>,
 }
 
+pubenumAttrSuggestionStyle{
+/// The suggestion is styled for a normal attribute.
+/// The `AttrStyle` determines whether this is an inner or outer attribute.
+Attribute(AttrStyle),
+/// The suggestion is styled for an attribute embedded into another attribute.
+/// For example, attributes inside `#[cfg_attr(true, attr(...)]`.
+EmbeddedAttribute,
+/// The suggestion is styled for macros that are parsed with attribute parsers.
+/// For example, the `cfg!(predicate)` macro.
+Macro,
+}
+
 implAttributeTemplate{
 pubfnsuggestions(
 &self,
-style:Option<AttrStyle>,
+style:AttrSuggestionStyle,
 name:impl std::fmt::Display,
 ) -> Vec<String>{
-letmut suggestions = vec![];
-let(start, end) =match style {
-Some(AttrStyle::Outer) => ("#[","]"),
-Some(AttrStyle::Inner) => ("#![","]"),
-None => ("",""),
+let(start, macro_call, end) = match style {
+AttrSuggestionStyle::Attribute(AttrStyle::Outer) => ("#[","","]"),
+AttrSuggestionStyle::Attribute(AttrStyle::Inner) => ("#![","","]"),
+AttrSuggestionStyle::Macro => ("","!",""),
+AttrSuggestionStyle::EmbeddedAttribute => ("","",""),
 };
+
+letmut suggestions = vec![];
+
 ifself.word{
+debug_assert!(macro_call.is_empty(),"Macro suggestions use list style");
  suggestions.push(format!("{start}{name}{end}"));
 }
 ifletSome(descr) = self.list{
 for descr in descr {
- suggestions.push(format!("{start}{name}({descr}){end}"));
+ suggestions.push(format!("{start}{name}{macro_call}({descr}){end}"));
 }
 }
  suggestions.extend(self.one_of.iter().map(|&word| format!("{start}{name}({word}){end}")));
 ifletSome(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}"));
 }

compiler/rustc_feature/src/lib.rs

@@ -129,9 +129,10 @@ pub fn find_feature_issue(feature: Symbol, issue: GateIssue) -> Option<NonZero<u
 
 pubuse accepted::ACCEPTED_LANG_FEATURES;
 pubuse builtin_attrs::{
-AttributeDuplicates,AttributeGate,AttributeSafety,AttributeTemplate,AttributeType,
-BUILTIN_ATTRIBUTE_MAP,BUILTIN_ATTRIBUTES,BuiltinAttribute,GatedCfg, encode_cross_crate,
- find_gated_cfg, is_builtin_attr_name, is_stable_diagnostic_attribute, is_valid_for_get_attr,
+AttrSuggestionStyle,AttributeDuplicates,AttributeGate,AttributeSafety,AttributeTemplate,
+AttributeType,BUILTIN_ATTRIBUTE_MAP,BUILTIN_ATTRIBUTES,BuiltinAttribute,GatedCfg,
+ encode_cross_crate, find_gated_cfg, is_builtin_attr_name, is_stable_diagnostic_attribute,
+ is_valid_for_get_attr,
 };
 pubuse removed::REMOVED_LANG_FEATURES;
 pubuse unstable::{

compiler/rustc_hir_analysis/src/check/check.rs

@@ -1542,22 +1542,10 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
 
 let typing_env = ty::TypingEnv::non_body_analysis(tcx, adt.did());
 // For each field, figure out if it has "trivial" layout (i.e., is a 1-ZST).
-// Even some 1-ZST fields are not allowed though, if they have `non_exhaustive` or private
-// fields or `repr(C)`. We call those fields "unsuited".
 structFieldInfo<'tcx>{
 span:Span,
 trivial:bool,
-unsuited:Option<UnsuitedInfo<'tcx>>,
-}
-structUnsuitedInfo<'tcx>{
-/// The source of the problem, a type that is found somewhere within the field type.
 ty:Ty<'tcx>,
-reason:UnsuitedReason,
-}
-enumUnsuitedReason{
-NonExhaustive,
-PrivateField,
-ReprC,
 }
 
 let field_infos = adt.all_fields().map(|field| {
@@ -1566,60 +1554,7 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
 // We are currently checking the type this field came from, so it must be local
 let span = tcx.hir_span_if_local(field.did).unwrap();
 let trivial = layout.is_ok_and(|layout| layout.is_1zst());
-if !trivial {
-// No need to even compute `unsuited`.
-returnFieldInfo{ span, trivial,unsuited:None};
-}
-
-fncheck_unsuited<'tcx>(
-tcx:TyCtxt<'tcx>,
-typing_env: ty::TypingEnv<'tcx>,
-ty:Ty<'tcx>,
-) -> ControlFlow<UnsuitedInfo<'tcx>>{
-// We can encounter projections during traversal, so ensure the type is normalized.
-let ty = tcx.try_normalize_erasing_regions(typing_env, ty).unwrap_or(ty);
-match ty.kind(){
- ty::Tuple(list) => list.iter().try_for_each(|t| check_unsuited(tcx, typing_env, t)),
- ty::Array(ty, _) => check_unsuited(tcx, typing_env,*ty),
- ty::Adt(def, args) => {
-if !def.did().is_local()
- && !find_attr!(
- tcx.get_all_attrs(def.did()),
-AttributeKind::PubTransparent(_)
-)
-{
-let non_exhaustive = def.is_variant_list_non_exhaustive()
- || def
-.variants()
-.iter()
-.any(ty::VariantDef::is_field_list_non_exhaustive);
-let has_priv = def.all_fields().any(|f| !f.vis.is_public());
-if non_exhaustive || has_priv {
-returnControlFlow::Break(UnsuitedInfo{
- ty,
-reason:if non_exhaustive {
-UnsuitedReason::NonExhaustive
-}else{
-UnsuitedReason::PrivateField
-},
-});
-}
-}
-if def.repr().c(){
-returnControlFlow::Break(UnsuitedInfo{
- ty,
-reason:UnsuitedReason::ReprC,
-});
-}
- def.all_fields()
-.map(|field| field.ty(tcx, args))
-.try_for_each(|t| check_unsuited(tcx, typing_env, t))
-}
- _ => ControlFlow::Continue(()),
-}
-}
-
-FieldInfo{ span, trivial,unsuited:check_unsuited(tcx, typing_env, ty).break_value()}
+FieldInfo{ span, trivial, ty }
 });
 
 let non_trivial_fields = field_infos
@@ -1637,10 +1572,63 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
 return;
 }
 
+// Even some 1-ZST fields are not allowed though, if they have `non_exhaustive` or private
+// fields or `repr(C)`. We call those fields "unsuited".
+structUnsuitedInfo<'tcx>{
+/// The source of the problem, a type that is found somewhere within the field type.
+ty:Ty<'tcx>,
+reason:UnsuitedReason,
+}
+enumUnsuitedReason{
+NonExhaustive,
+PrivateField,
+ReprC,
+}
+
+fncheck_unsuited<'tcx>(
+tcx:TyCtxt<'tcx>,
+typing_env: ty::TypingEnv<'tcx>,
+ty:Ty<'tcx>,
+) -> ControlFlow<UnsuitedInfo<'tcx>>{
+// We can encounter projections during traversal, so ensure the type is normalized.
+let ty = tcx.try_normalize_erasing_regions(typing_env, ty).unwrap_or(ty);
+match ty.kind(){
+ ty::Tuple(list) => list.iter().try_for_each(|t| check_unsuited(tcx, typing_env, t)),
+ ty::Array(ty, _) => check_unsuited(tcx, typing_env,*ty),
+ ty::Adt(def, args) => {
+if !def.did().is_local()
+ && !find_attr!(tcx.get_all_attrs(def.did()),AttributeKind::PubTransparent(_))
+{
+let non_exhaustive = def.is_variant_list_non_exhaustive()
+ || def.variants().iter().any(ty::VariantDef::is_field_list_non_exhaustive);
+let has_priv = def.all_fields().any(|f| !f.vis.is_public());
+if non_exhaustive || has_priv {
+returnControlFlow::Break(UnsuitedInfo{
+ ty,
+reason:if non_exhaustive {
+UnsuitedReason::NonExhaustive
+}else{
+UnsuitedReason::PrivateField
+},
+});
+}
+}
+if def.repr().c(){
+returnControlFlow::Break(UnsuitedInfo{ ty,reason:UnsuitedReason::ReprC});
+}
+ def.all_fields()
+.map(|field| field.ty(tcx, args))
+.try_for_each(|t| check_unsuited(tcx, typing_env, t))
+}
+ _ => ControlFlow::Continue(()),
+}
+}
+
 letmut prev_unsuited_1zst = false;
 for field in field_infos {
-ifletSome(unsuited) = field.unsuited{
-assert!(field.trivial);
+if field.trivial
+ && letSome(unsuited) = check_unsuited(tcx, typing_env, field.ty).break_value()
+{
 // If there are any non-trivial fields, then there can be no non-exhaustive 1-zsts.
 // Otherwise, it's only an issue if there's >1 non-exhaustive 1-zst.
 if non_trivial_count > 0 || prev_unsuited_1zst {

compiler/rustc_metadata/src/rmeta/table.rs

@@ -55,8 +55,10 @@ impl IsDefault for UnusedGenericParams {
 
 /// Helper trait, for encoding to, and decoding from, a fixed number of bytes.
 /// Used mainly for Lazy positions and lengths.
-/// Unchecked invariant: `Self::default()` should encode as `[0; BYTE_LEN]`,
+///
+/// Invariant: `Self::default()` should encode as `[0; BYTE_LEN]`,
 /// but this has no impact on safety.
+/// In debug builds, this invariant is checked in `[TableBuilder::set]`
 pub(super)traitFixedSizeEncoding:IsDefault{
 /// This should be `[u8; BYTE_LEN]`;
 /// Cannot use an associated `const BYTE_LEN: usize` instead due to const eval limitations.
@@ -432,6 +434,13 @@ impl<I: Idx, const N: usize, T: FixedSizeEncoding<ByteArray = [u8; N]>> TableBui
 /// arises in the future then a new method (e.g. `clear` or `reset`) will need to be introduced
 /// for doing that explicitly.
 pub(crate)fnset(&mutself,i:I,value:T){
+#[cfg(debug_assertions)]
+{
+debug_assert!(
+T::from_bytes(&[0;N]).is_default(),
+"expected all-zeroes to decode to the default value, as per the invariant of FixedSizeEncoding"
+);
+}
 if !value.is_default(){
 // FIXME(eddyb) investigate more compact encodings for sparse tables.
 // On the PR @michaelwoerister mentioned:

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -2,7 +2,7 @@ use rustc_ast::token::Delimiter;
 use rustc_ast::tokenstream::DelimSpan;
 use rustc_ast::{AttrItem,Attribute,CRATE_NODE_ID,LitKind,NodeId, ast, token};
 use rustc_errors::{Applicability,PResult};
-use rustc_feature::{AttributeTemplate,Features, template};
+use rustc_feature::{AttrSuggestionStyle,AttributeTemplate,Features, template};
 use rustc_hir::attrs::CfgEntry;
 use rustc_hir::{AttrPath,RustcVersion};
 use rustc_parse::parser::{ForceCollect,Parser};
@@ -323,8 +323,8 @@ pub fn parse_cfg_attr(
 }){
 Ok(r) => returnSome(r),
 Err(e) => {
-let suggestions =
-CFG_ATTR_TEMPLATE.suggestions(Some(cfg_attr.style), sym::cfg_attr);
+let suggestions =CFG_ATTR_TEMPLATE
+.suggestions(AttrSuggestionStyle::Attribute(cfg_attr.style), sym::cfg_attr);
  e.with_span_suggestions(
  cfg_attr.span,
 "must be of the form",
@@ -355,7 +355,8 @@ pub fn parse_cfg_attr(
 path:AttrPath::from_ast(&cfg_attr.get_normal_item().path),
 description:ParsedDescription::Attribute,
  reason,
-suggestions:CFG_ATTR_TEMPLATE.suggestions(Some(cfg_attr.style), sym::cfg_attr),
+suggestions:CFG_ATTR_TEMPLATE
+.suggestions(AttrSuggestionStyle::Attribute(cfg_attr.style), sym::cfg_attr),
 });
 }
 }

compiler/rustc_attr_parsing/src/context.rs

@@ -6,7 +6,7 @@ use std::sync::LazyLock;
 use private::Sealed;
 use rustc_ast::{AttrStyle,CRATE_NODE_ID,MetaItemLit,NodeId};
 use rustc_errors::{Diag,Diagnostic,Level};
-use rustc_feature::AttributeTemplate;
+use rustc_feature::{AttrSuggestionStyle,AttributeTemplate};
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::lints::{AttributeLint,AttributeLintKind};
 use rustc_hir::{AttrPath,CRATE_HIR_ID,HirId};
@@ -637,9 +637,15 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
 }
 
 pub(crate)fnsuggestions(&self) -> Vec<String>{
-// If the outer and inner spans are equal, we are parsing an attribute from `cfg_attr`,
-// So don't display an attribute style in the suggestions
-let style = (self.attr_span != self.inner_span).then_some(self.attr_style);
+let style = matchself.parsed_description{
+// If the outer and inner spans are equal, we are parsing an embedded attribute
+ParsedDescription::Attributeifself.attr_span == self.inner_span => {
+AttrSuggestionStyle::EmbeddedAttribute
+}
+ParsedDescription::Attribute => AttrSuggestionStyle::Attribute(self.attr_style),
+ParsedDescription::Macro => AttrSuggestionStyle::Macro,
+};
+
 self.template.suggestions(style,&self.attr_path)
 }
 }

compiler/rustc_feature/src/builtin_attrs.rs

@@ -132,28 +132,45 @@ pub struct AttributeTemplate {
 pubdocs:Option<&'staticstr>,
 }
 
+pubenumAttrSuggestionStyle{
+/// The suggestion is styled for a normal attribute.
+/// The `AttrStyle` determines whether this is an inner or outer attribute.
+Attribute(AttrStyle),
+/// The suggestion is styled for an attribute embedded into another attribute.
+/// For example, attributes inside `#[cfg_attr(true, attr(...)]`.
+EmbeddedAttribute,
+/// The suggestion is styled for macros that are parsed with attribute parsers.
+/// For example, the `cfg!(predicate)` macro.
+Macro,
+}
+
 implAttributeTemplate{
 pubfnsuggestions(
 &self,
-style:Option<AttrStyle>,
+style:AttrSuggestionStyle,
 name:impl std::fmt::Display,
 ) -> Vec<String>{
-letmut suggestions = vec![];
-let(start, end) =match style {
-Some(AttrStyle::Outer) => ("#[","]"),
-Some(AttrStyle::Inner) => ("#![","]"),
-None => ("",""),
+let(start, macro_call, end) = match style {
+AttrSuggestionStyle::Attribute(AttrStyle::Outer) => ("#[","","]"),
+AttrSuggestionStyle::Attribute(AttrStyle::Inner) => ("#![","","]"),
+AttrSuggestionStyle::Macro => ("","!",""),
+AttrSuggestionStyle::EmbeddedAttribute => ("","",""),
 };
+
+letmut suggestions = vec![];
+
 ifself.word{
+debug_assert!(macro_call.is_empty(),"Macro suggestions use list style");
  suggestions.push(format!("{start}{name}{end}"));
 }
 ifletSome(descr) = self.list{
 for descr in descr {
- suggestions.push(format!("{start}{name}({descr}){end}"));
+ suggestions.push(format!("{start}{name}{macro_call}({descr}){end}"));
 }
 }
  suggestions.extend(self.one_of.iter().map(|&word| format!("{start}{name}({word}){end}")));
 ifletSome(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}"));
 }

compiler/rustc_feature/src/lib.rs

@@ -129,9 +129,10 @@ pub fn find_feature_issue(feature: Symbol, issue: GateIssue) -> Option<NonZero<u
 
 pubuse accepted::ACCEPTED_LANG_FEATURES;
 pubuse builtin_attrs::{
-AttributeDuplicates,AttributeGate,AttributeSafety,AttributeTemplate,AttributeType,
-BUILTIN_ATTRIBUTE_MAP,BUILTIN_ATTRIBUTES,BuiltinAttribute,GatedCfg, encode_cross_crate,
- find_gated_cfg, is_builtin_attr_name, is_stable_diagnostic_attribute, is_valid_for_get_attr,
+AttrSuggestionStyle,AttributeDuplicates,AttributeGate,AttributeSafety,AttributeTemplate,
+AttributeType,BUILTIN_ATTRIBUTE_MAP,BUILTIN_ATTRIBUTES,BuiltinAttribute,GatedCfg,
+ encode_cross_crate, find_gated_cfg, is_builtin_attr_name, is_stable_diagnostic_attribute,
+ is_valid_for_get_attr,
 };
 pubuse removed::REMOVED_LANG_FEATURES;
 pubuse unstable::{

compiler/rustc_hir_analysis/src/check/check.rs

@@ -1542,22 +1542,10 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
 
 let typing_env = ty::TypingEnv::non_body_analysis(tcx, adt.did());
 // For each field, figure out if it has "trivial" layout (i.e., is a 1-ZST).
-// Even some 1-ZST fields are not allowed though, if they have `non_exhaustive` or private
-// fields or `repr(C)`. We call those fields "unsuited".
 structFieldInfo<'tcx>{
 span:Span,
 trivial:bool,
-unsuited:Option<UnsuitedInfo<'tcx>>,
-}
-structUnsuitedInfo<'tcx>{
-/// The source of the problem, a type that is found somewhere within the field type.
 ty:Ty<'tcx>,
-reason:UnsuitedReason,
-}
-enumUnsuitedReason{
-NonExhaustive,
-PrivateField,
-ReprC,
 }
 
 let field_infos = adt.all_fields().map(|field| {
@@ -1566,60 +1554,7 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
 // We are currently checking the type this field came from, so it must be local
 let span = tcx.hir_span_if_local(field.did).unwrap();
 let trivial = layout.is_ok_and(|layout| layout.is_1zst());
-if !trivial {
-// No need to even compute `unsuited`.
-returnFieldInfo{ span, trivial,unsuited:None};
-}
-
-fncheck_unsuited<'tcx>(
-tcx:TyCtxt<'tcx>,
-typing_env: ty::TypingEnv<'tcx>,
-ty:Ty<'tcx>,
-) -> ControlFlow<UnsuitedInfo<'tcx>>{
-// We can encounter projections during traversal, so ensure the type is normalized.
-let ty = tcx.try_normalize_erasing_regions(typing_env, ty).unwrap_or(ty);
-match ty.kind(){
- ty::Tuple(list) => list.iter().try_for_each(|t| check_unsuited(tcx, typing_env, t)),
- ty::Array(ty, _) => check_unsuited(tcx, typing_env,*ty),
- ty::Adt(def, args) => {
-if !def.did().is_local()
- && !find_attr!(
- tcx.get_all_attrs(def.did()),
-AttributeKind::PubTransparent(_)
-)
-{
-let non_exhaustive = def.is_variant_list_non_exhaustive()
- || def
-.variants()
-.iter()
-.any(ty::VariantDef::is_field_list_non_exhaustive);
-let has_priv = def.all_fields().any(|f| !f.vis.is_public());
-if non_exhaustive || has_priv {
-returnControlFlow::Break(UnsuitedInfo{
- ty,
-reason:if non_exhaustive {
-UnsuitedReason::NonExhaustive
-}else{
-UnsuitedReason::PrivateField
-},
-});
-}
-}
-if def.repr().c(){
-returnControlFlow::Break(UnsuitedInfo{
- ty,
-reason:UnsuitedReason::ReprC,
-});
-}
- def.all_fields()
-.map(|field| field.ty(tcx, args))
-.try_for_each(|t| check_unsuited(tcx, typing_env, t))
-}
- _ => ControlFlow::Continue(()),
-}
-}
-
-FieldInfo{ span, trivial,unsuited:check_unsuited(tcx, typing_env, ty).break_value()}
+FieldInfo{ span, trivial, ty }
 });
 
 let non_trivial_fields = field_infos
@@ -1637,10 +1572,63 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
 return;
 }
 
+// Even some 1-ZST fields are not allowed though, if they have `non_exhaustive` or private
+// fields or `repr(C)`. We call those fields "unsuited".
+structUnsuitedInfo<'tcx>{
+/// The source of the problem, a type that is found somewhere within the field type.
+ty:Ty<'tcx>,
+reason:UnsuitedReason,
+}
+enumUnsuitedReason{
+NonExhaustive,
+PrivateField,
+ReprC,
+}
+
+fncheck_unsuited<'tcx>(
+tcx:TyCtxt<'tcx>,
+typing_env: ty::TypingEnv<'tcx>,
+ty:Ty<'tcx>,
+) -> ControlFlow<UnsuitedInfo<'tcx>>{
+// We can encounter projections during traversal, so ensure the type is normalized.
+let ty = tcx.try_normalize_erasing_regions(typing_env, ty).unwrap_or(ty);
+match ty.kind(){
+ ty::Tuple(list) => list.iter().try_for_each(|t| check_unsuited(tcx, typing_env, t)),
+ ty::Array(ty, _) => check_unsuited(tcx, typing_env,*ty),
+ ty::Adt(def, args) => {
+if !def.did().is_local()
+ && !find_attr!(tcx.get_all_attrs(def.did()),AttributeKind::PubTransparent(_))
+{
+let non_exhaustive = def.is_variant_list_non_exhaustive()
+ || def.variants().iter().any(ty::VariantDef::is_field_list_non_exhaustive);
+let has_priv = def.all_fields().any(|f| !f.vis.is_public());
+if non_exhaustive || has_priv {
+returnControlFlow::Break(UnsuitedInfo{
+ ty,
+reason:if non_exhaustive {
+UnsuitedReason::NonExhaustive
+}else{
+UnsuitedReason::PrivateField
+},
+});
+}
+}
+if def.repr().c(){
+returnControlFlow::Break(UnsuitedInfo{ ty,reason:UnsuitedReason::ReprC});
+}
+ def.all_fields()
+.map(|field| field.ty(tcx, args))
+.try_for_each(|t| check_unsuited(tcx, typing_env, t))
+}
+ _ => ControlFlow::Continue(()),
+}
+}
+
 letmut prev_unsuited_1zst = false;
 for field in field_infos {
-ifletSome(unsuited) = field.unsuited{
-assert!(field.trivial);
+if field.trivial
+ && letSome(unsuited) = check_unsuited(tcx, typing_env, field.ty).break_value()
+{
 // If there are any non-trivial fields, then there can be no non-exhaustive 1-zsts.
 // Otherwise, it's only an issue if there's >1 non-exhaustive 1-zst.
 if non_trivial_count > 0 || prev_unsuited_1zst {

compiler/rustc_metadata/src/rmeta/table.rs

@@ -55,8 +55,10 @@ impl IsDefault for UnusedGenericParams {
 
 /// Helper trait, for encoding to, and decoding from, a fixed number of bytes.
 /// Used mainly for Lazy positions and lengths.
-/// Unchecked invariant: `Self::default()` should encode as `[0; BYTE_LEN]`,
+///
+/// Invariant: `Self::default()` should encode as `[0; BYTE_LEN]`,
 /// but this has no impact on safety.
+/// In debug builds, this invariant is checked in `[TableBuilder::set]`
 pub(super)traitFixedSizeEncoding:IsDefault{
 /// This should be `[u8; BYTE_LEN]`;
 /// Cannot use an associated `const BYTE_LEN: usize` instead due to const eval limitations.
@@ -432,6 +434,13 @@ impl<I: Idx, const N: usize, T: FixedSizeEncoding<ByteArray = [u8; N]>> TableBui
 /// arises in the future then a new method (e.g. `clear` or `reset`) will need to be introduced
 /// for doing that explicitly.
 pub(crate)fnset(&mutself,i:I,value:T){
+#[cfg(debug_assertions)]
+{
+debug_assert!(
+T::from_bytes(&[0;N]).is_default(),
+"expected all-zeroes to decode to the default value, as per the invariant of FixedSizeEncoding"
+);
+}
 if !value.is_default(){
 // FIXME(eddyb) investigate more compact encodings for sparse tables.
 // On the PR @michaelwoerister mentioned:

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -2,7 +2,7 @@ use rustc_ast::token::Delimiter;
 use rustc_ast::tokenstream::DelimSpan;
 use rustc_ast::{AttrItem,Attribute,CRATE_NODE_ID,LitKind,NodeId, ast, token};
 use rustc_errors::{Applicability,PResult};
-use rustc_feature::{AttributeTemplate,Features, template};
+use rustc_feature::{AttrSuggestionStyle,AttributeTemplate,Features, template};
 use rustc_hir::attrs::CfgEntry;
 use rustc_hir::{AttrPath,RustcVersion};
 use rustc_parse::parser::{ForceCollect,Parser};
@@ -323,8 +323,8 @@ pub fn parse_cfg_attr(
 }){
 Ok(r) => returnSome(r),
 Err(e) => {
-let suggestions =
-CFG_ATTR_TEMPLATE.suggestions(Some(cfg_attr.style), sym::cfg_attr);
+let suggestions =CFG_ATTR_TEMPLATE
+.suggestions(AttrSuggestionStyle::Attribute(cfg_attr.style), sym::cfg_attr);
  e.with_span_suggestions(
  cfg_attr.span,
 "must be of the form",
@@ -355,7 +355,8 @@ pub fn parse_cfg_attr(
 path:AttrPath::from_ast(&cfg_attr.get_normal_item().path),
 description:ParsedDescription::Attribute,
  reason,
-suggestions:CFG_ATTR_TEMPLATE.suggestions(Some(cfg_attr.style), sym::cfg_attr),
+suggestions:CFG_ATTR_TEMPLATE
+.suggestions(AttrSuggestionStyle::Attribute(cfg_attr.style), sym::cfg_attr),
 });
 }
 }

compiler/rustc_attr_parsing/src/context.rs

@@ -6,7 +6,7 @@ use std::sync::LazyLock;
 use private::Sealed;
 use rustc_ast::{AttrStyle,CRATE_NODE_ID,MetaItemLit,NodeId};
 use rustc_errors::{Diag,Diagnostic,Level};
-use rustc_feature::AttributeTemplate;
+use rustc_feature::{AttrSuggestionStyle,AttributeTemplate};
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::lints::{AttributeLint,AttributeLintKind};
 use rustc_hir::{AttrPath,CRATE_HIR_ID,HirId};
@@ -637,9 +637,15 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
 }
 
 pub(crate)fnsuggestions(&self) -> Vec<String>{
-// If the outer and inner spans are equal, we are parsing an attribute from `cfg_attr`,
-// So don't display an attribute style in the suggestions
-let style = (self.attr_span != self.inner_span).then_some(self.attr_style);
+let style = matchself.parsed_description{
+// If the outer and inner spans are equal, we are parsing an embedded attribute
+ParsedDescription::Attributeifself.attr_span == self.inner_span => {
+AttrSuggestionStyle::EmbeddedAttribute
+}
+ParsedDescription::Attribute => AttrSuggestionStyle::Attribute(self.attr_style),
+ParsedDescription::Macro => AttrSuggestionStyle::Macro,
+};
+
 self.template.suggestions(style,&self.attr_path)
 }
 }

compiler/rustc_feature/src/builtin_attrs.rs

@@ -132,28 +132,45 @@ pub struct AttributeTemplate {
 pubdocs:Option<&'staticstr>,
 }
 
+pubenumAttrSuggestionStyle{
+/// The suggestion is styled for a normal attribute.
+/// The `AttrStyle` determines whether this is an inner or outer attribute.
+Attribute(AttrStyle),
+/// The suggestion is styled for an attribute embedded into another attribute.
+/// For example, attributes inside `#[cfg_attr(true, attr(...)]`.
+EmbeddedAttribute,
+/// The suggestion is styled for macros that are parsed with attribute parsers.
+/// For example, the `cfg!(predicate)` macro.
+Macro,
+}
+
 implAttributeTemplate{
 pubfnsuggestions(
 &self,
-style:Option<AttrStyle>,
+style:AttrSuggestionStyle,
 name:impl std::fmt::Display,
 ) -> Vec<String>{
-letmut suggestions = vec![];
-let(start, end) =match style {
-Some(AttrStyle::Outer) => ("#[","]"),
-Some(AttrStyle::Inner) => ("#![","]"),
-None => ("",""),
+let(start, macro_call, end) = match style {
+AttrSuggestionStyle::Attribute(AttrStyle::Outer) => ("#[","","]"),
+AttrSuggestionStyle::Attribute(AttrStyle::Inner) => ("#![","","]"),
+AttrSuggestionStyle::Macro => ("","!",""),
+AttrSuggestionStyle::EmbeddedAttribute => ("","",""),
 };
+
+letmut suggestions = vec![];
+
 ifself.word{
+debug_assert!(macro_call.is_empty(),"Macro suggestions use list style");
  suggestions.push(format!("{start}{name}{end}"));
 }
 ifletSome(descr) = self.list{
 for descr in descr {
- suggestions.push(format!("{start}{name}({descr}){end}"));
+ suggestions.push(format!("{start}{name}{macro_call}({descr}){end}"));
 }
 }
  suggestions.extend(self.one_of.iter().map(|&word| format!("{start}{name}({word}){end}")));
 ifletSome(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}"));
 }

compiler/rustc_feature/src/lib.rs

@@ -129,9 +129,10 @@ pub fn find_feature_issue(feature: Symbol, issue: GateIssue) -> Option<NonZero<u
 
 pubuse accepted::ACCEPTED_LANG_FEATURES;
 pubuse builtin_attrs::{
-AttributeDuplicates,AttributeGate,AttributeSafety,AttributeTemplate,AttributeType,
-BUILTIN_ATTRIBUTE_MAP,BUILTIN_ATTRIBUTES,BuiltinAttribute,GatedCfg, encode_cross_crate,
- find_gated_cfg, is_builtin_attr_name, is_stable_diagnostic_attribute, is_valid_for_get_attr,
+AttrSuggestionStyle,AttributeDuplicates,AttributeGate,AttributeSafety,AttributeTemplate,
+AttributeType,BUILTIN_ATTRIBUTE_MAP,BUILTIN_ATTRIBUTES,BuiltinAttribute,GatedCfg,
+ encode_cross_crate, find_gated_cfg, is_builtin_attr_name, is_stable_diagnostic_attribute,
+ is_valid_for_get_attr,
 };
 pubuse removed::REMOVED_LANG_FEATURES;
 pubuse unstable::{

compiler/rustc_hir_analysis/src/check/check.rs

@@ -1542,22 +1542,10 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
 
 let typing_env = ty::TypingEnv::non_body_analysis(tcx, adt.did());
 // For each field, figure out if it has "trivial" layout (i.e., is a 1-ZST).
-// Even some 1-ZST fields are not allowed though, if they have `non_exhaustive` or private
-// fields or `repr(C)`. We call those fields "unsuited".
 structFieldInfo<'tcx>{
 span:Span,
 trivial:bool,
-unsuited:Option<UnsuitedInfo<'tcx>>,
-}
-structUnsuitedInfo<'tcx>{
-/// The source of the problem, a type that is found somewhere within the field type.
 ty:Ty<'tcx>,
-reason:UnsuitedReason,
-}
-enumUnsuitedReason{
-NonExhaustive,
-PrivateField,
-ReprC,
 }
 
 let field_infos = adt.all_fields().map(|field| {
@@ -1566,60 +1554,7 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
 // We are currently checking the type this field came from, so it must be local
 let span = tcx.hir_span_if_local(field.did).unwrap();
 let trivial = layout.is_ok_and(|layout| layout.is_1zst());
-if !trivial {
-// No need to even compute `unsuited`.
-returnFieldInfo{ span, trivial,unsuited:None};
-}
-
-fncheck_unsuited<'tcx>(
-tcx:TyCtxt<'tcx>,
-typing_env: ty::TypingEnv<'tcx>,
-ty:Ty<'tcx>,
-) -> ControlFlow<UnsuitedInfo<'tcx>>{
-// We can encounter projections during traversal, so ensure the type is normalized.
-let ty = tcx.try_normalize_erasing_regions(typing_env, ty).unwrap_or(ty);
-match ty.kind(){
- ty::Tuple(list) => list.iter().try_for_each(|t| check_unsuited(tcx, typing_env, t)),
- ty::Array(ty, _) => check_unsuited(tcx, typing_env,*ty),
- ty::Adt(def, args) => {
-if !def.did().is_local()
- && !find_attr!(
- tcx.get_all_attrs(def.did()),
-AttributeKind::PubTransparent(_)
-)
-{
-let non_exhaustive = def.is_variant_list_non_exhaustive()
- || def
-.variants()
-.iter()
-.any(ty::VariantDef::is_field_list_non_exhaustive);
-let has_priv = def.all_fields().any(|f| !f.vis.is_public());
-if non_exhaustive || has_priv {
-returnControlFlow::Break(UnsuitedInfo{
- ty,
-reason:if non_exhaustive {
-UnsuitedReason::NonExhaustive
-}else{
-UnsuitedReason::PrivateField
-},
-});
-}
-}
-if def.repr().c(){
-returnControlFlow::Break(UnsuitedInfo{
- ty,
-reason:UnsuitedReason::ReprC,
-});
-}
- def.all_fields()
-.map(|field| field.ty(tcx, args))
-.try_for_each(|t| check_unsuited(tcx, typing_env, t))
-}
- _ => ControlFlow::Continue(()),
-}
-}
-
-FieldInfo{ span, trivial,unsuited:check_unsuited(tcx, typing_env, ty).break_value()}
+FieldInfo{ span, trivial, ty }
 });
 
 let non_trivial_fields = field_infos
@@ -1637,10 +1572,63 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
 return;
 }
 
+// Even some 1-ZST fields are not allowed though, if they have `non_exhaustive` or private
+// fields or `repr(C)`. We call those fields "unsuited".
+structUnsuitedInfo<'tcx>{
+/// The source of the problem, a type that is found somewhere within the field type.
+ty:Ty<'tcx>,
+reason:UnsuitedReason,
+}
+enumUnsuitedReason{
+NonExhaustive,
+PrivateField,
+ReprC,
+}
+
+fncheck_unsuited<'tcx>(
+tcx:TyCtxt<'tcx>,
+typing_env: ty::TypingEnv<'tcx>,
+ty:Ty<'tcx>,
+) -> ControlFlow<UnsuitedInfo<'tcx>>{
+// We can encounter projections during traversal, so ensure the type is normalized.
+let ty = tcx.try_normalize_erasing_regions(typing_env, ty).unwrap_or(ty);
+match ty.kind(){
+ ty::Tuple(list) => list.iter().try_for_each(|t| check_unsuited(tcx, typing_env, t)),
+ ty::Array(ty, _) => check_unsuited(tcx, typing_env,*ty),
+ ty::Adt(def, args) => {
+if !def.did().is_local()
+ && !find_attr!(tcx.get_all_attrs(def.did()),AttributeKind::PubTransparent(_))
+{
+let non_exhaustive = def.is_variant_list_non_exhaustive()
+ || def.variants().iter().any(ty::VariantDef::is_field_list_non_exhaustive);
+let has_priv = def.all_fields().any(|f| !f.vis.is_public());
+if non_exhaustive || has_priv {
+returnControlFlow::Break(UnsuitedInfo{
+ ty,
+reason:if non_exhaustive {
+UnsuitedReason::NonExhaustive
+}else{
+UnsuitedReason::PrivateField
+},
+});
+}
+}
+if def.repr().c(){
+returnControlFlow::Break(UnsuitedInfo{ ty,reason:UnsuitedReason::ReprC});
+}
+ def.all_fields()
+.map(|field| field.ty(tcx, args))
+.try_for_each(|t| check_unsuited(tcx, typing_env, t))
+}
+ _ => ControlFlow::Continue(()),
+}
+}
+
 letmut prev_unsuited_1zst = false;
 for field in field_infos {
-ifletSome(unsuited) = field.unsuited{
-assert!(field.trivial);
+if field.trivial
+ && letSome(unsuited) = check_unsuited(tcx, typing_env, field.ty).break_value()
+{
 // If there are any non-trivial fields, then there can be no non-exhaustive 1-zsts.
 // Otherwise, it's only an issue if there's >1 non-exhaustive 1-zst.
 if non_trivial_count > 0 || prev_unsuited_1zst {

compiler/rustc_metadata/src/rmeta/table.rs

@@ -55,8 +55,10 @@ impl IsDefault for UnusedGenericParams {
 
 /// Helper trait, for encoding to, and decoding from, a fixed number of bytes.
 /// Used mainly for Lazy positions and lengths.
-/// Unchecked invariant: `Self::default()` should encode as `[0; BYTE_LEN]`,
+///
+/// Invariant: `Self::default()` should encode as `[0; BYTE_LEN]`,
 /// but this has no impact on safety.
+/// In debug builds, this invariant is checked in `[TableBuilder::set]`
 pub(super)traitFixedSizeEncoding:IsDefault{
 /// This should be `[u8; BYTE_LEN]`;
 /// Cannot use an associated `const BYTE_LEN: usize` instead due to const eval limitations.
@@ -432,6 +434,13 @@ impl<I: Idx, const N: usize, T: FixedSizeEncoding<ByteArray = [u8; N]>> TableBui
 /// arises in the future then a new method (e.g. `clear` or `reset`) will need to be introduced
 /// for doing that explicitly.
 pub(crate)fnset(&mutself,i:I,value:T){
+#[cfg(debug_assertions)]
+{
+debug_assert!(
+T::from_bytes(&[0;N]).is_default(),
+"expected all-zeroes to decode to the default value, as per the invariant of FixedSizeEncoding"
+);
+}
 if !value.is_default(){
 // FIXME(eddyb) investigate more compact encodings for sparse tables.
 // On the PR @michaelwoerister mentioned:

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -2,7 +2,7 @@ use rustc_ast::token::Delimiter;
 use rustc_ast::tokenstream::DelimSpan;
 use rustc_ast::{AttrItem,Attribute,CRATE_NODE_ID,LitKind,NodeId, ast, token};
 use rustc_errors::{Applicability,PResult};
-use rustc_feature::{AttributeTemplate,Features, template};
+use rustc_feature::{AttrSuggestionStyle,AttributeTemplate,Features, template};
 use rustc_hir::attrs::CfgEntry;
 use rustc_hir::{AttrPath,RustcVersion};
 use rustc_parse::parser::{ForceCollect,Parser};
@@ -323,8 +323,8 @@ pub fn parse_cfg_attr(
 }){
 Ok(r) => returnSome(r),
 Err(e) => {
-let suggestions =
-CFG_ATTR_TEMPLATE.suggestions(Some(cfg_attr.style), sym::cfg_attr);
+let suggestions =CFG_ATTR_TEMPLATE
+.suggestions(AttrSuggestionStyle::Attribute(cfg_attr.style), sym::cfg_attr);
  e.with_span_suggestions(
  cfg_attr.span,
 "must be of the form",
@@ -355,7 +355,8 @@ pub fn parse_cfg_attr(
 path:AttrPath::from_ast(&cfg_attr.get_normal_item().path),
 description:ParsedDescription::Attribute,
  reason,
-suggestions:CFG_ATTR_TEMPLATE.suggestions(Some(cfg_attr.style), sym::cfg_attr),
+suggestions:CFG_ATTR_TEMPLATE
+.suggestions(AttrSuggestionStyle::Attribute(cfg_attr.style), sym::cfg_attr),
 });
 }
 }

compiler/rustc_attr_parsing/src/context.rs

@@ -6,7 +6,7 @@ use std::sync::LazyLock;
 use private::Sealed;
 use rustc_ast::{AttrStyle,CRATE_NODE_ID,MetaItemLit,NodeId};
 use rustc_errors::{Diag,Diagnostic,Level};
-use rustc_feature::AttributeTemplate;
+use rustc_feature::{AttrSuggestionStyle,AttributeTemplate};
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::lints::{AttributeLint,AttributeLintKind};
 use rustc_hir::{AttrPath,CRATE_HIR_ID,HirId};
@@ -637,9 +637,15 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
 }
 
 pub(crate)fnsuggestions(&self) -> Vec<String>{
-// If the outer and inner spans are equal, we are parsing an attribute from `cfg_attr`,
-// So don't display an attribute style in the suggestions
-let style = (self.attr_span != self.inner_span).then_some(self.attr_style);
+let style = matchself.parsed_description{
+// If the outer and inner spans are equal, we are parsing an embedded attribute
+ParsedDescription::Attributeifself.attr_span == self.inner_span => {
+AttrSuggestionStyle::EmbeddedAttribute
+}
+ParsedDescription::Attribute => AttrSuggestionStyle::Attribute(self.attr_style),
+ParsedDescription::Macro => AttrSuggestionStyle::Macro,
+};
+
 self.template.suggestions(style,&self.attr_path)
 }
 }

compiler/rustc_feature/src/builtin_attrs.rs

@@ -132,28 +132,45 @@ pub struct AttributeTemplate {
 pubdocs:Option<&'staticstr>,
 }
 
+pubenumAttrSuggestionStyle{
+/// The suggestion is styled for a normal attribute.
+/// The `AttrStyle` determines whether this is an inner or outer attribute.
+Attribute(AttrStyle),
+/// The suggestion is styled for an attribute embedded into another attribute.
+/// For example, attributes inside `#[cfg_attr(true, attr(...)]`.
+EmbeddedAttribute,
+/// The suggestion is styled for macros that are parsed with attribute parsers.
+/// For example, the `cfg!(predicate)` macro.
+Macro,
+}
+
 implAttributeTemplate{
 pubfnsuggestions(
 &self,
-style:Option<AttrStyle>,
+style:AttrSuggestionStyle,
 name:impl std::fmt::Display,
 ) -> Vec<String>{
-letmut suggestions = vec![];
-let(start, end) =match style {
-Some(AttrStyle::Outer) => ("#[","]"),
-Some(AttrStyle::Inner) => ("#![","]"),
-None => ("",""),
+let(start, macro_call, end) = match style {
+AttrSuggestionStyle::Attribute(AttrStyle::Outer) => ("#[","","]"),
+AttrSuggestionStyle::Attribute(AttrStyle::Inner) => ("#![","","]"),
+AttrSuggestionStyle::Macro => ("","!",""),
+AttrSuggestionStyle::EmbeddedAttribute => ("","",""),
 };
+
+letmut suggestions = vec![];
+
 ifself.word{
+debug_assert!(macro_call.is_empty(),"Macro suggestions use list style");
  suggestions.push(format!("{start}{name}{end}"));
 }
 ifletSome(descr) = self.list{
 for descr in descr {
- suggestions.push(format!("{start}{name}({descr}){end}"));
+ suggestions.push(format!("{start}{name}{macro_call}({descr}){end}"));
 }
 }
  suggestions.extend(self.one_of.iter().map(|&word| format!("{start}{name}({word}){end}")));
 ifletSome(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}"));
 }

compiler/rustc_feature/src/lib.rs

@@ -129,9 +129,10 @@ pub fn find_feature_issue(feature: Symbol, issue: GateIssue) -> Option<NonZero<u
 
 pubuse accepted::ACCEPTED_LANG_FEATURES;
 pubuse builtin_attrs::{
-AttributeDuplicates,AttributeGate,AttributeSafety,AttributeTemplate,AttributeType,
-BUILTIN_ATTRIBUTE_MAP,BUILTIN_ATTRIBUTES,BuiltinAttribute,GatedCfg, encode_cross_crate,
- find_gated_cfg, is_builtin_attr_name, is_stable_diagnostic_attribute, is_valid_for_get_attr,
+AttrSuggestionStyle,AttributeDuplicates,AttributeGate,AttributeSafety,AttributeTemplate,
+AttributeType,BUILTIN_ATTRIBUTE_MAP,BUILTIN_ATTRIBUTES,BuiltinAttribute,GatedCfg,
+ encode_cross_crate, find_gated_cfg, is_builtin_attr_name, is_stable_diagnostic_attribute,
+ is_valid_for_get_attr,
 };
 pubuse removed::REMOVED_LANG_FEATURES;
 pubuse unstable::{

compiler/rustc_hir_analysis/src/check/check.rs

@@ -1542,22 +1542,10 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
 
 let typing_env = ty::TypingEnv::non_body_analysis(tcx, adt.did());
 // For each field, figure out if it has "trivial" layout (i.e., is a 1-ZST).
-// Even some 1-ZST fields are not allowed though, if they have `non_exhaustive` or private
-// fields or `repr(C)`. We call those fields "unsuited".
 structFieldInfo<'tcx>{
 span:Span,
 trivial:bool,
-unsuited:Option<UnsuitedInfo<'tcx>>,
-}
-structUnsuitedInfo<'tcx>{
-/// The source of the problem, a type that is found somewhere within the field type.
 ty:Ty<'tcx>,
-reason:UnsuitedReason,
-}
-enumUnsuitedReason{
-NonExhaustive,
-PrivateField,
-ReprC,
 }
 
 let field_infos = adt.all_fields().map(|field| {
@@ -1566,60 +1554,7 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
 // We are currently checking the type this field came from, so it must be local
 let span = tcx.hir_span_if_local(field.did).unwrap();
 let trivial = layout.is_ok_and(|layout| layout.is_1zst());
-if !trivial {
-// No need to even compute `unsuited`.
-returnFieldInfo{ span, trivial,unsuited:None};
-}
-
-fncheck_unsuited<'tcx>(
-tcx:TyCtxt<'tcx>,
-typing_env: ty::TypingEnv<'tcx>,
-ty:Ty<'tcx>,
-) -> ControlFlow<UnsuitedInfo<'tcx>>{
-// We can encounter projections during traversal, so ensure the type is normalized.
-let ty = tcx.try_normalize_erasing_regions(typing_env, ty).unwrap_or(ty);
-match ty.kind(){
- ty::Tuple(list) => list.iter().try_for_each(|t| check_unsuited(tcx, typing_env, t)),
- ty::Array(ty, _) => check_unsuited(tcx, typing_env,*ty),
- ty::Adt(def, args) => {
-if !def.did().is_local()
- && !find_attr!(
- tcx.get_all_attrs(def.did()),
-AttributeKind::PubTransparent(_)
-)
-{
-let non_exhaustive = def.is_variant_list_non_exhaustive()
- || def
-.variants()
-.iter()
-.any(ty::VariantDef::is_field_list_non_exhaustive);
-let has_priv = def.all_fields().any(|f| !f.vis.is_public());
-if non_exhaustive || has_priv {
-returnControlFlow::Break(UnsuitedInfo{
- ty,
-reason:if non_exhaustive {
-UnsuitedReason::NonExhaustive
-}else{
-UnsuitedReason::PrivateField
-},
-});
-}
-}
-if def.repr().c(){
-returnControlFlow::Break(UnsuitedInfo{
- ty,
-reason:UnsuitedReason::ReprC,
-});
-}
- def.all_fields()
-.map(|field| field.ty(tcx, args))
-.try_for_each(|t| check_unsuited(tcx, typing_env, t))
-}
- _ => ControlFlow::Continue(()),
-}
-}
-
-FieldInfo{ span, trivial,unsuited:check_unsuited(tcx, typing_env, ty).break_value()}
+FieldInfo{ span, trivial, ty }
 });
 
 let non_trivial_fields = field_infos
@@ -1637,10 +1572,63 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
 return;
 }
 
+// Even some 1-ZST fields are not allowed though, if they have `non_exhaustive` or private
+// fields or `repr(C)`. We call those fields "unsuited".
+structUnsuitedInfo<'tcx>{
+/// The source of the problem, a type that is found somewhere within the field type.
+ty:Ty<'tcx>,
+reason:UnsuitedReason,
+}
+enumUnsuitedReason{
+NonExhaustive,
+PrivateField,
+ReprC,
+}
+
+fncheck_unsuited<'tcx>(
+tcx:TyCtxt<'tcx>,
+typing_env: ty::TypingEnv<'tcx>,
+ty:Ty<'tcx>,
+) -> ControlFlow<UnsuitedInfo<'tcx>>{
+// We can encounter projections during traversal, so ensure the type is normalized.
+let ty = tcx.try_normalize_erasing_regions(typing_env, ty).unwrap_or(ty);
+match ty.kind(){
+ ty::Tuple(list) => list.iter().try_for_each(|t| check_unsuited(tcx, typing_env, t)),
+ ty::Array(ty, _) => check_unsuited(tcx, typing_env,*ty),
+ ty::Adt(def, args) => {
+if !def.did().is_local()
+ && !find_attr!(tcx.get_all_attrs(def.did()),AttributeKind::PubTransparent(_))
+{
+let non_exhaustive = def.is_variant_list_non_exhaustive()
+ || def.variants().iter().any(ty::VariantDef::is_field_list_non_exhaustive);
+let has_priv = def.all_fields().any(|f| !f.vis.is_public());
+if non_exhaustive || has_priv {
+returnControlFlow::Break(UnsuitedInfo{
+ ty,
+reason:if non_exhaustive {
+UnsuitedReason::NonExhaustive
+}else{
+UnsuitedReason::PrivateField
+},
+});
+}
+}
+if def.repr().c(){
+returnControlFlow::Break(UnsuitedInfo{ ty,reason:UnsuitedReason::ReprC});
+}
+ def.all_fields()
+.map(|field| field.ty(tcx, args))
+.try_for_each(|t| check_unsuited(tcx, typing_env, t))
+}
+ _ => ControlFlow::Continue(()),
+}
+}
+
 letmut prev_unsuited_1zst = false;
 for field in field_infos {
-ifletSome(unsuited) = field.unsuited{
-assert!(field.trivial);
+if field.trivial
+ && letSome(unsuited) = check_unsuited(tcx, typing_env, field.ty).break_value()
+{
 // If there are any non-trivial fields, then there can be no non-exhaustive 1-zsts.
 // Otherwise, it's only an issue if there's >1 non-exhaustive 1-zst.
 if non_trivial_count > 0 || prev_unsuited_1zst {

compiler/rustc_metadata/src/rmeta/table.rs

@@ -55,8 +55,10 @@ impl IsDefault for UnusedGenericParams {
 
 /// Helper trait, for encoding to, and decoding from, a fixed number of bytes.
 /// Used mainly for Lazy positions and lengths.
-/// Unchecked invariant: `Self::default()` should encode as `[0; BYTE_LEN]`,
+///
+/// Invariant: `Self::default()` should encode as `[0; BYTE_LEN]`,
 /// but this has no impact on safety.
+/// In debug builds, this invariant is checked in `[TableBuilder::set]`
 pub(super)traitFixedSizeEncoding:IsDefault{
 /// This should be `[u8; BYTE_LEN]`;
 /// Cannot use an associated `const BYTE_LEN: usize` instead due to const eval limitations.
@@ -432,6 +434,13 @@ impl<I: Idx, const N: usize, T: FixedSizeEncoding<ByteArray = [u8; N]>> TableBui
 /// arises in the future then a new method (e.g. `clear` or `reset`) will need to be introduced
 /// for doing that explicitly.
 pub(crate)fnset(&mutself,i:I,value:T){
+#[cfg(debug_assertions)]
+{
+debug_assert!(
+T::from_bytes(&[0;N]).is_default(),
+"expected all-zeroes to decode to the default value, as per the invariant of FixedSizeEncoding"
+);
+}
 if !value.is_default(){
 // FIXME(eddyb) investigate more compact encodings for sparse tables.
 // On the PR @michaelwoerister mentioned:

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -2,7 +2,7 @@ use rustc_ast::token::Delimiter;
 use rustc_ast::tokenstream::DelimSpan;
 use rustc_ast::{AttrItem,Attribute,CRATE_NODE_ID,LitKind,NodeId, ast, token};
 use rustc_errors::{Applicability,PResult};
-use rustc_feature::{AttributeTemplate,Features, template};
+use rustc_feature::{AttrSuggestionStyle,AttributeTemplate,Features, template};
 use rustc_hir::attrs::CfgEntry;
 use rustc_hir::{AttrPath,RustcVersion};
 use rustc_parse::parser::{ForceCollect,Parser};
@@ -323,8 +323,8 @@ pub fn parse_cfg_attr(
 }){
 Ok(r) => returnSome(r),
 Err(e) => {
-let suggestions =
-CFG_ATTR_TEMPLATE.suggestions(Some(cfg_attr.style), sym::cfg_attr);
+let suggestions =CFG_ATTR_TEMPLATE
+.suggestions(AttrSuggestionStyle::Attribute(cfg_attr.style), sym::cfg_attr);
  e.with_span_suggestions(
  cfg_attr.span,
 "must be of the form",
@@ -355,7 +355,8 @@ pub fn parse_cfg_attr(
 path:AttrPath::from_ast(&cfg_attr.get_normal_item().path),
 description:ParsedDescription::Attribute,
  reason,
-suggestions:CFG_ATTR_TEMPLATE.suggestions(Some(cfg_attr.style), sym::cfg_attr),
+suggestions:CFG_ATTR_TEMPLATE
+.suggestions(AttrSuggestionStyle::Attribute(cfg_attr.style), sym::cfg_attr),
 });
 }
 }

compiler/rustc_attr_parsing/src/context.rs

@@ -6,7 +6,7 @@ use std::sync::LazyLock;
 use private::Sealed;
 use rustc_ast::{AttrStyle,CRATE_NODE_ID,MetaItemLit,NodeId};
 use rustc_errors::{Diag,Diagnostic,Level};
-use rustc_feature::AttributeTemplate;
+use rustc_feature::{AttrSuggestionStyle,AttributeTemplate};
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::lints::{AttributeLint,AttributeLintKind};
 use rustc_hir::{AttrPath,CRATE_HIR_ID,HirId};
@@ -637,9 +637,15 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
 }
 
 pub(crate)fnsuggestions(&self) -> Vec<String>{
-// If the outer and inner spans are equal, we are parsing an attribute from `cfg_attr`,
-// So don't display an attribute style in the suggestions
-let style = (self.attr_span != self.inner_span).then_some(self.attr_style);
+let style = matchself.parsed_description{
+// If the outer and inner spans are equal, we are parsing an embedded attribute
+ParsedDescription::Attributeifself.attr_span == self.inner_span => {
+AttrSuggestionStyle::EmbeddedAttribute
+}
+ParsedDescription::Attribute => AttrSuggestionStyle::Attribute(self.attr_style),
+ParsedDescription::Macro => AttrSuggestionStyle::Macro,
+};
+
 self.template.suggestions(style,&self.attr_path)
 }
 }

compiler/rustc_feature/src/builtin_attrs.rs

@@ -132,28 +132,45 @@ pub struct AttributeTemplate {
 pubdocs:Option<&'staticstr>,
 }
 
+pubenumAttrSuggestionStyle{
+/// The suggestion is styled for a normal attribute.
+/// The `AttrStyle` determines whether this is an inner or outer attribute.
+Attribute(AttrStyle),
+/// The suggestion is styled for an attribute embedded into another attribute.
+/// For example, attributes inside `#[cfg_attr(true, attr(...)]`.
+EmbeddedAttribute,
+/// The suggestion is styled for macros that are parsed with attribute parsers.
+/// For example, the `cfg!(predicate)` macro.
+Macro,
+}
+
 implAttributeTemplate{
 pubfnsuggestions(
 &self,
-style:Option<AttrStyle>,
+style:AttrSuggestionStyle,
 name:impl std::fmt::Display,
 ) -> Vec<String>{
-letmut suggestions = vec![];
-let(start, end) =match style {
-Some(AttrStyle::Outer) => ("#[","]"),
-Some(AttrStyle::Inner) => ("#![","]"),
-None => ("",""),
+let(start, macro_call, end) = match style {
+AttrSuggestionStyle::Attribute(AttrStyle::Outer) => ("#[","","]"),
+AttrSuggestionStyle::Attribute(AttrStyle::Inner) => ("#![","","]"),
+AttrSuggestionStyle::Macro => ("","!",""),
+AttrSuggestionStyle::EmbeddedAttribute => ("","",""),
 };
+
+letmut suggestions = vec![];
+
 ifself.word{
+debug_assert!(macro_call.is_empty(),"Macro suggestions use list style");
  suggestions.push(format!("{start}{name}{end}"));
 }
 ifletSome(descr) = self.list{
 for descr in descr {
- suggestions.push(format!("{start}{name}({descr}){end}"));
+ suggestions.push(format!("{start}{name}{macro_call}({descr}){end}"));
 }
 }
  suggestions.extend(self.one_of.iter().map(|&word| format!("{start}{name}({word}){end}")));
 ifletSome(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}"));
 }

compiler/rustc_feature/src/lib.rs

@@ -129,9 +129,10 @@ pub fn find_feature_issue(feature: Symbol, issue: GateIssue) -> Option<NonZero<u
 
 pubuse accepted::ACCEPTED_LANG_FEATURES;
 pubuse builtin_attrs::{
-AttributeDuplicates,AttributeGate,AttributeSafety,AttributeTemplate,AttributeType,
-BUILTIN_ATTRIBUTE_MAP,BUILTIN_ATTRIBUTES,BuiltinAttribute,GatedCfg, encode_cross_crate,
- find_gated_cfg, is_builtin_attr_name, is_stable_diagnostic_attribute, is_valid_for_get_attr,
+AttrSuggestionStyle,AttributeDuplicates,AttributeGate,AttributeSafety,AttributeTemplate,
+AttributeType,BUILTIN_ATTRIBUTE_MAP,BUILTIN_ATTRIBUTES,BuiltinAttribute,GatedCfg,
+ encode_cross_crate, find_gated_cfg, is_builtin_attr_name, is_stable_diagnostic_attribute,
+ is_valid_for_get_attr,
 };
 pubuse removed::REMOVED_LANG_FEATURES;
 pubuse unstable::{

compiler/rustc_hir_analysis/src/check/check.rs

@@ -1542,22 +1542,10 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
 
 let typing_env = ty::TypingEnv::non_body_analysis(tcx, adt.did());
 // For each field, figure out if it has "trivial" layout (i.e., is a 1-ZST).
-// Even some 1-ZST fields are not allowed though, if they have `non_exhaustive` or private
-// fields or `repr(C)`. We call those fields "unsuited".
 structFieldInfo<'tcx>{
 span:Span,
 trivial:bool,
-unsuited:Option<UnsuitedInfo<'tcx>>,
-}
-structUnsuitedInfo<'tcx>{
-/// The source of the problem, a type that is found somewhere within the field type.
 ty:Ty<'tcx>,
-reason:UnsuitedReason,
-}
-enumUnsuitedReason{
-NonExhaustive,
-PrivateField,
-ReprC,
 }
 
 let field_infos = adt.all_fields().map(|field| {
@@ -1566,60 +1554,7 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
 // We are currently checking the type this field came from, so it must be local
 let span = tcx.hir_span_if_local(field.did).unwrap();
 let trivial = layout.is_ok_and(|layout| layout.is_1zst());
-if !trivial {
-// No need to even compute `unsuited`.
-returnFieldInfo{ span, trivial,unsuited:None};
-}
-
-fncheck_unsuited<'tcx>(
-tcx:TyCtxt<'tcx>,
-typing_env: ty::TypingEnv<'tcx>,
-ty:Ty<'tcx>,
-) -> ControlFlow<UnsuitedInfo<'tcx>>{
-// We can encounter projections during traversal, so ensure the type is normalized.
-let ty = tcx.try_normalize_erasing_regions(typing_env, ty).unwrap_or(ty);
-match ty.kind(){
- ty::Tuple(list) => list.iter().try_for_each(|t| check_unsuited(tcx, typing_env, t)),
- ty::Array(ty, _) => check_unsuited(tcx, typing_env,*ty),
- ty::Adt(def, args) => {
-if !def.did().is_local()
- && !find_attr!(
- tcx.get_all_attrs(def.did()),
-AttributeKind::PubTransparent(_)
-)
-{
-let non_exhaustive = def.is_variant_list_non_exhaustive()
- || def
-.variants()
-.iter()
-.any(ty::VariantDef::is_field_list_non_exhaustive);
-let has_priv = def.all_fields().any(|f| !f.vis.is_public());
-if non_exhaustive || has_priv {
-returnControlFlow::Break(UnsuitedInfo{
- ty,
-reason:if non_exhaustive {
-UnsuitedReason::NonExhaustive
-}else{
-UnsuitedReason::PrivateField
-},
-});
-}
-}
-if def.repr().c(){
-returnControlFlow::Break(UnsuitedInfo{
- ty,
-reason:UnsuitedReason::ReprC,
-});
-}
- def.all_fields()
-.map(|field| field.ty(tcx, args))
-.try_for_each(|t| check_unsuited(tcx, typing_env, t))
-}
- _ => ControlFlow::Continue(()),
-}
-}
-
-FieldInfo{ span, trivial,unsuited:check_unsuited(tcx, typing_env, ty).break_value()}
+FieldInfo{ span, trivial, ty }
 });
 
 let non_trivial_fields = field_infos
@@ -1637,10 +1572,63 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
 return;
 }
 
+// Even some 1-ZST fields are not allowed though, if they have `non_exhaustive` or private
+// fields or `repr(C)`. We call those fields "unsuited".
+structUnsuitedInfo<'tcx>{
+/// The source of the problem, a type that is found somewhere within the field type.
+ty:Ty<'tcx>,
+reason:UnsuitedReason,
+}
+enumUnsuitedReason{
+NonExhaustive,
+PrivateField,
+ReprC,
+}
+
+fncheck_unsuited<'tcx>(
+tcx:TyCtxt<'tcx>,
+typing_env: ty::TypingEnv<'tcx>,
+ty:Ty<'tcx>,
+) -> ControlFlow<UnsuitedInfo<'tcx>>{
+// We can encounter projections during traversal, so ensure the type is normalized.
+let ty = tcx.try_normalize_erasing_regions(typing_env, ty).unwrap_or(ty);
+match ty.kind(){
+ ty::Tuple(list) => list.iter().try_for_each(|t| check_unsuited(tcx, typing_env, t)),
+ ty::Array(ty, _) => check_unsuited(tcx, typing_env,*ty),
+ ty::Adt(def, args) => {
+if !def.did().is_local()
+ && !find_attr!(tcx.get_all_attrs(def.did()),AttributeKind::PubTransparent(_))
+{
+let non_exhaustive = def.is_variant_list_non_exhaustive()
+ || def.variants().iter().any(ty::VariantDef::is_field_list_non_exhaustive);
+let has_priv = def.all_fields().any(|f| !f.vis.is_public());
+if non_exhaustive || has_priv {
+returnControlFlow::Break(UnsuitedInfo{
+ ty,
+reason:if non_exhaustive {
+UnsuitedReason::NonExhaustive
+}else{
+UnsuitedReason::PrivateField
+},
+});
+}
+}
+if def.repr().c(){
+returnControlFlow::Break(UnsuitedInfo{ ty,reason:UnsuitedReason::ReprC});
+}
+ def.all_fields()
+.map(|field| field.ty(tcx, args))
+.try_for_each(|t| check_unsuited(tcx, typing_env, t))
+}
+ _ => ControlFlow::Continue(()),
+}
+}
+
 letmut prev_unsuited_1zst = false;
 for field in field_infos {
-ifletSome(unsuited) = field.unsuited{
-assert!(field.trivial);
+if field.trivial
+ && letSome(unsuited) = check_unsuited(tcx, typing_env, field.ty).break_value()
+{
 // If there are any non-trivial fields, then there can be no non-exhaustive 1-zsts.
 // Otherwise, it's only an issue if there's >1 non-exhaustive 1-zst.
 if non_trivial_count > 0 || prev_unsuited_1zst {

compiler/rustc_metadata/src/rmeta/table.rs

@@ -55,8 +55,10 @@ impl IsDefault for UnusedGenericParams {
 
 /// Helper trait, for encoding to, and decoding from, a fixed number of bytes.
 /// Used mainly for Lazy positions and lengths.
-/// Unchecked invariant: `Self::default()` should encode as `[0; BYTE_LEN]`,
+///
+/// Invariant: `Self::default()` should encode as `[0; BYTE_LEN]`,
 /// but this has no impact on safety.
+/// In debug builds, this invariant is checked in `[TableBuilder::set]`
 pub(super)traitFixedSizeEncoding:IsDefault{
 /// This should be `[u8; BYTE_LEN]`;
 /// Cannot use an associated `const BYTE_LEN: usize` instead due to const eval limitations.
@@ -432,6 +434,13 @@ impl<I: Idx, const N: usize, T: FixedSizeEncoding<ByteArray = [u8; N]>> TableBui
 /// arises in the future then a new method (e.g. `clear` or `reset`) will need to be introduced
 /// for doing that explicitly.
 pub(crate)fnset(&mutself,i:I,value:T){
+#[cfg(debug_assertions)]
+{
+debug_assert!(
+T::from_bytes(&[0;N]).is_default(),
+"expected all-zeroes to decode to the default value, as per the invariant of FixedSizeEncoding"
+);
+}
 if !value.is_default(){
 // FIXME(eddyb) investigate more compact encodings for sparse tables.
 // On the PR @michaelwoerister mentioned:

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -2,7 +2,7 @@ use rustc_ast::token::Delimiter;
 use rustc_ast::tokenstream::DelimSpan;
 use rustc_ast::{AttrItem,Attribute,CRATE_NODE_ID,LitKind,NodeId, ast, token};
 use rustc_errors::{Applicability,PResult};
-use rustc_feature::{AttributeTemplate,Features, template};
+use rustc_feature::{AttrSuggestionStyle,AttributeTemplate,Features, template};
 use rustc_hir::attrs::CfgEntry;
 use rustc_hir::{AttrPath,RustcVersion};
 use rustc_parse::parser::{ForceCollect,Parser};
@@ -323,8 +323,8 @@ pub fn parse_cfg_attr(
 }){
 Ok(r) => returnSome(r),
 Err(e) => {
-let suggestions =
-CFG_ATTR_TEMPLATE.suggestions(Some(cfg_attr.style), sym::cfg_attr);
+let suggestions =CFG_ATTR_TEMPLATE
+.suggestions(AttrSuggestionStyle::Attribute(cfg_attr.style), sym::cfg_attr);
  e.with_span_suggestions(
  cfg_attr.span,
 "must be of the form",
@@ -355,7 +355,8 @@ pub fn parse_cfg_attr(
 path:AttrPath::from_ast(&cfg_attr.get_normal_item().path),
 description:ParsedDescription::Attribute,
  reason,
-suggestions:CFG_ATTR_TEMPLATE.suggestions(Some(cfg_attr.style), sym::cfg_attr),
+suggestions:CFG_ATTR_TEMPLATE
+.suggestions(AttrSuggestionStyle::Attribute(cfg_attr.style), sym::cfg_attr),
 });
 }
 }

compiler/rustc_attr_parsing/src/context.rs

@@ -6,7 +6,7 @@ use std::sync::LazyLock;
 use private::Sealed;
 use rustc_ast::{AttrStyle,CRATE_NODE_ID,MetaItemLit,NodeId};
 use rustc_errors::{Diag,Diagnostic,Level};
-use rustc_feature::AttributeTemplate;
+use rustc_feature::{AttrSuggestionStyle,AttributeTemplate};
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::lints::{AttributeLint,AttributeLintKind};
 use rustc_hir::{AttrPath,CRATE_HIR_ID,HirId};
@@ -637,9 +637,15 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
 }
 
 pub(crate)fnsuggestions(&self) -> Vec<String>{
-// If the outer and inner spans are equal, we are parsing an attribute from `cfg_attr`,
-// So don't display an attribute style in the suggestions
-let style = (self.attr_span != self.inner_span).then_some(self.attr_style);
+let style = matchself.parsed_description{
+// If the outer and inner spans are equal, we are parsing an embedded attribute
+ParsedDescription::Attributeifself.attr_span == self.inner_span => {
+AttrSuggestionStyle::EmbeddedAttribute
+}
+ParsedDescription::Attribute => AttrSuggestionStyle::Attribute(self.attr_style),
+ParsedDescription::Macro => AttrSuggestionStyle::Macro,
+};
+
 self.template.suggestions(style,&self.attr_path)
 }
 }

compiler/rustc_feature/src/builtin_attrs.rs

@@ -132,28 +132,45 @@ pub struct AttributeTemplate {
 pubdocs:Option<&'staticstr>,
 }
 
+pubenumAttrSuggestionStyle{
+/// The suggestion is styled for a normal attribute.
+/// The `AttrStyle` determines whether this is an inner or outer attribute.
+Attribute(AttrStyle),
+/// The suggestion is styled for an attribute embedded into another attribute.
+/// For example, attributes inside `#[cfg_attr(true, attr(...)]`.
+EmbeddedAttribute,
+/// The suggestion is styled for macros that are parsed with attribute parsers.
+/// For example, the `cfg!(predicate)` macro.
+Macro,
+}
+
 implAttributeTemplate{
 pubfnsuggestions(
 &self,
-style:Option<AttrStyle>,
+style:AttrSuggestionStyle,
 name:impl std::fmt::Display,
 ) -> Vec<String>{
-letmut suggestions = vec![];
-let(start, end) =match style {
-Some(AttrStyle::Outer) => ("#[","]"),
-Some(AttrStyle::Inner) => ("#![","]"),
-None => ("",""),
+let(start, macro_call, end) = match style {
+AttrSuggestionStyle::Attribute(AttrStyle::Outer) => ("#[","","]"),
+AttrSuggestionStyle::Attribute(AttrStyle::Inner) => ("#![","","]"),
+AttrSuggestionStyle::Macro => ("","!",""),
+AttrSuggestionStyle::EmbeddedAttribute => ("","",""),
 };
+
+letmut suggestions = vec![];
+
 ifself.word{
+debug_assert!(macro_call.is_empty(),"Macro suggestions use list style");
  suggestions.push(format!("{start}{name}{end}"));
 }
 ifletSome(descr) = self.list{
 for descr in descr {
- suggestions.push(format!("{start}{name}({descr}){end}"));
+ suggestions.push(format!("{start}{name}{macro_call}({descr}){end}"));
 }
 }
  suggestions.extend(self.one_of.iter().map(|&word| format!("{start}{name}({word}){end}")));
 ifletSome(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}"));
 }

compiler/rustc_feature/src/lib.rs

@@ -129,9 +129,10 @@ pub fn find_feature_issue(feature: Symbol, issue: GateIssue) -> Option<NonZero<u
 
 pubuse accepted::ACCEPTED_LANG_FEATURES;
 pubuse builtin_attrs::{
-AttributeDuplicates,AttributeGate,AttributeSafety,AttributeTemplate,AttributeType,
-BUILTIN_ATTRIBUTE_MAP,BUILTIN_ATTRIBUTES,BuiltinAttribute,GatedCfg, encode_cross_crate,
- find_gated_cfg, is_builtin_attr_name, is_stable_diagnostic_attribute, is_valid_for_get_attr,
+AttrSuggestionStyle,AttributeDuplicates,AttributeGate,AttributeSafety,AttributeTemplate,
+AttributeType,BUILTIN_ATTRIBUTE_MAP,BUILTIN_ATTRIBUTES,BuiltinAttribute,GatedCfg,
+ encode_cross_crate, find_gated_cfg, is_builtin_attr_name, is_stable_diagnostic_attribute,
+ is_valid_for_get_attr,
 };
 pubuse removed::REMOVED_LANG_FEATURES;
 pubuse unstable::{

compiler/rustc_hir_analysis/src/check/check.rs

@@ -1542,22 +1542,10 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
 
 let typing_env = ty::TypingEnv::non_body_analysis(tcx, adt.did());
 // For each field, figure out if it has "trivial" layout (i.e., is a 1-ZST).
-// Even some 1-ZST fields are not allowed though, if they have `non_exhaustive` or private
-// fields or `repr(C)`. We call those fields "unsuited".
 structFieldInfo<'tcx>{
 span:Span,
 trivial:bool,
-unsuited:Option<UnsuitedInfo<'tcx>>,
-}
-structUnsuitedInfo<'tcx>{
-/// The source of the problem, a type that is found somewhere within the field type.
 ty:Ty<'tcx>,
-reason:UnsuitedReason,
-}
-enumUnsuitedReason{
-NonExhaustive,
-PrivateField,
-ReprC,
 }
 
 let field_infos = adt.all_fields().map(|field| {
@@ -1566,60 +1554,7 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
 // We are currently checking the type this field came from, so it must be local
 let span = tcx.hir_span_if_local(field.did).unwrap();
 let trivial = layout.is_ok_and(|layout| layout.is_1zst());
-if !trivial {
-// No need to even compute `unsuited`.
-returnFieldInfo{ span, trivial,unsuited:None};
-}
-
-fncheck_unsuited<'tcx>(
-tcx:TyCtxt<'tcx>,
-typing_env: ty::TypingEnv<'tcx>,
-ty:Ty<'tcx>,
-) -> ControlFlow<UnsuitedInfo<'tcx>>{
-// We can encounter projections during traversal, so ensure the type is normalized.
-let ty = tcx.try_normalize_erasing_regions(typing_env, ty).unwrap_or(ty);
-match ty.kind(){
- ty::Tuple(list) => list.iter().try_for_each(|t| check_unsuited(tcx, typing_env, t)),
- ty::Array(ty, _) => check_unsuited(tcx, typing_env,*ty),
- ty::Adt(def, args) => {
-if !def.did().is_local()
- && !find_attr!(
- tcx.get_all_attrs(def.did()),
-AttributeKind::PubTransparent(_)
-)
-{
-let non_exhaustive = def.is_variant_list_non_exhaustive()
- || def
-.variants()
-.iter()
-.any(ty::VariantDef::is_field_list_non_exhaustive);
-let has_priv = def.all_fields().any(|f| !f.vis.is_public());
-if non_exhaustive || has_priv {
-returnControlFlow::Break(UnsuitedInfo{
- ty,
-reason:if non_exhaustive {
-UnsuitedReason::NonExhaustive
-}else{
-UnsuitedReason::PrivateField
-},
-});
-}
-}
-if def.repr().c(){
-returnControlFlow::Break(UnsuitedInfo{
- ty,
-reason:UnsuitedReason::ReprC,
-});
-}
- def.all_fields()
-.map(|field| field.ty(tcx, args))
-.try_for_each(|t| check_unsuited(tcx, typing_env, t))
-}
- _ => ControlFlow::Continue(()),
-}
-}
-
-FieldInfo{ span, trivial,unsuited:check_unsuited(tcx, typing_env, ty).break_value()}
+FieldInfo{ span, trivial, ty }
 });
 
 let non_trivial_fields = field_infos
@@ -1637,10 +1572,63 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
 return;
 }
 
+// Even some 1-ZST fields are not allowed though, if they have `non_exhaustive` or private
+// fields or `repr(C)`. We call those fields "unsuited".
+structUnsuitedInfo<'tcx>{
+/// The source of the problem, a type that is found somewhere within the field type.
+ty:Ty<'tcx>,
+reason:UnsuitedReason,
+}
+enumUnsuitedReason{
+NonExhaustive,
+PrivateField,
+ReprC,
+}
+
+fncheck_unsuited<'tcx>(
+tcx:TyCtxt<'tcx>,
+typing_env: ty::TypingEnv<'tcx>,
+ty:Ty<'tcx>,
+) -> ControlFlow<UnsuitedInfo<'tcx>>{
+// We can encounter projections during traversal, so ensure the type is normalized.
+let ty = tcx.try_normalize_erasing_regions(typing_env, ty).unwrap_or(ty);
+match ty.kind(){
+ ty::Tuple(list) => list.iter().try_for_each(|t| check_unsuited(tcx, typing_env, t)),
+ ty::Array(ty, _) => check_unsuited(tcx, typing_env,*ty),
+ ty::Adt(def, args) => {
+if !def.did().is_local()
+ && !find_attr!(tcx.get_all_attrs(def.did()),AttributeKind::PubTransparent(_))
+{
+let non_exhaustive = def.is_variant_list_non_exhaustive()
+ || def.variants().iter().any(ty::VariantDef::is_field_list_non_exhaustive);
+let has_priv = def.all_fields().any(|f| !f.vis.is_public());
+if non_exhaustive || has_priv {
+returnControlFlow::Break(UnsuitedInfo{
+ ty,
+reason:if non_exhaustive {
+UnsuitedReason::NonExhaustive
+}else{
+UnsuitedReason::PrivateField
+},
+});
+}
+}
+if def.repr().c(){
+returnControlFlow::Break(UnsuitedInfo{ ty,reason:UnsuitedReason::ReprC});
+}
+ def.all_fields()
+.map(|field| field.ty(tcx, args))
+.try_for_each(|t| check_unsuited(tcx, typing_env, t))
+}
+ _ => ControlFlow::Continue(()),
+}
+}
+
 letmut prev_unsuited_1zst = false;
 for field in field_infos {
-ifletSome(unsuited) = field.unsuited{
-assert!(field.trivial);
+if field.trivial
+ && letSome(unsuited) = check_unsuited(tcx, typing_env, field.ty).break_value()
+{
 // If there are any non-trivial fields, then there can be no non-exhaustive 1-zsts.
 // Otherwise, it's only an issue if there's >1 non-exhaustive 1-zst.
 if non_trivial_count > 0 || prev_unsuited_1zst {

compiler/rustc_metadata/src/rmeta/table.rs

@@ -55,8 +55,10 @@ impl IsDefault for UnusedGenericParams {
 
 /// Helper trait, for encoding to, and decoding from, a fixed number of bytes.
 /// Used mainly for Lazy positions and lengths.
-/// Unchecked invariant: `Self::default()` should encode as `[0; BYTE_LEN]`,
+///
+/// Invariant: `Self::default()` should encode as `[0; BYTE_LEN]`,
 /// but this has no impact on safety.
+/// In debug builds, this invariant is checked in `[TableBuilder::set]`
 pub(super)traitFixedSizeEncoding:IsDefault{
 /// This should be `[u8; BYTE_LEN]`;
 /// Cannot use an associated `const BYTE_LEN: usize` instead due to const eval limitations.
@@ -432,6 +434,13 @@ impl<I: Idx, const N: usize, T: FixedSizeEncoding<ByteArray = [u8; N]>> TableBui
 /// arises in the future then a new method (e.g. `clear` or `reset`) will need to be introduced
 /// for doing that explicitly.
 pub(crate)fnset(&mutself,i:I,value:T){
+#[cfg(debug_assertions)]
+{
+debug_assert!(
+T::from_bytes(&[0;N]).is_default(),
+"expected all-zeroes to decode to the default value, as per the invariant of FixedSizeEncoding"
+);
+}
 if !value.is_default(){
 // FIXME(eddyb) investigate more compact encodings for sparse tables.
 // On the PR @michaelwoerister mentioned:

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -2,7 +2,7 @@ use rustc_ast::token::Delimiter;
 use rustc_ast::tokenstream::DelimSpan;
 use rustc_ast::{AttrItem,Attribute,CRATE_NODE_ID,LitKind,NodeId, ast, token};
 use rustc_errors::{Applicability,PResult};
-use rustc_feature::{AttributeTemplate,Features, template};
+use rustc_feature::{AttrSuggestionStyle,AttributeTemplate,Features, template};
 use rustc_hir::attrs::CfgEntry;
 use rustc_hir::{AttrPath,RustcVersion};
 use rustc_parse::parser::{ForceCollect,Parser};
@@ -323,8 +323,8 @@ pub fn parse_cfg_attr(
 }){
 Ok(r) => returnSome(r),
 Err(e) => {
-let suggestions =
-CFG_ATTR_TEMPLATE.suggestions(Some(cfg_attr.style), sym::cfg_attr);
+let suggestions =CFG_ATTR_TEMPLATE
+.suggestions(AttrSuggestionStyle::Attribute(cfg_attr.style), sym::cfg_attr);
  e.with_span_suggestions(
  cfg_attr.span,
 "must be of the form",
@@ -355,7 +355,8 @@ pub fn parse_cfg_attr(
 path:AttrPath::from_ast(&cfg_attr.get_normal_item().path),
 description:ParsedDescription::Attribute,
  reason,
-suggestions:CFG_ATTR_TEMPLATE.suggestions(Some(cfg_attr.style), sym::cfg_attr),
+suggestions:CFG_ATTR_TEMPLATE
+.suggestions(AttrSuggestionStyle::Attribute(cfg_attr.style), sym::cfg_attr),
 });
 }
 }

compiler/rustc_attr_parsing/src/context.rs

@@ -6,7 +6,7 @@ use std::sync::LazyLock;
 use private::Sealed;
 use rustc_ast::{AttrStyle,CRATE_NODE_ID,MetaItemLit,NodeId};
 use rustc_errors::{Diag,Diagnostic,Level};
-use rustc_feature::AttributeTemplate;
+use rustc_feature::{AttrSuggestionStyle,AttributeTemplate};
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::lints::{AttributeLint,AttributeLintKind};
 use rustc_hir::{AttrPath,CRATE_HIR_ID,HirId};
@@ -637,9 +637,15 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
 }
 
 pub(crate)fnsuggestions(&self) -> Vec<String>{
-// If the outer and inner spans are equal, we are parsing an attribute from `cfg_attr`,
-// So don't display an attribute style in the suggestions
-let style = (self.attr_span != self.inner_span).then_some(self.attr_style);
+let style = matchself.parsed_description{
+// If the outer and inner spans are equal, we are parsing an embedded attribute
+ParsedDescription::Attributeifself.attr_span == self.inner_span => {
+AttrSuggestionStyle::EmbeddedAttribute
+}
+ParsedDescription::Attribute => AttrSuggestionStyle::Attribute(self.attr_style),
+ParsedDescription::Macro => AttrSuggestionStyle::Macro,
+};
+
 self.template.suggestions(style,&self.attr_path)
 }
 }

compiler/rustc_feature/src/builtin_attrs.rs

@@ -132,28 +132,45 @@ pub struct AttributeTemplate {
 pubdocs:Option<&'staticstr>,
 }
 
+pubenumAttrSuggestionStyle{
+/// The suggestion is styled for a normal attribute.
+/// The `AttrStyle` determines whether this is an inner or outer attribute.
+Attribute(AttrStyle),
+/// The suggestion is styled for an attribute embedded into another attribute.
+/// For example, attributes inside `#[cfg_attr(true, attr(...)]`.
+EmbeddedAttribute,
+/// The suggestion is styled for macros that are parsed with attribute parsers.
+/// For example, the `cfg!(predicate)` macro.
+Macro,
+}
+
 implAttributeTemplate{
 pubfnsuggestions(
 &self,
-style:Option<AttrStyle>,
+style:AttrSuggestionStyle,
 name:impl std::fmt::Display,
 ) -> Vec<String>{
-letmut suggestions = vec![];
-let(start, end) =match style {
-Some(AttrStyle::Outer) => ("#[","]"),
-Some(AttrStyle::Inner) => ("#![","]"),
-None => ("",""),
+let(start, macro_call, end) = match style {
+AttrSuggestionStyle::Attribute(AttrStyle::Outer) => ("#[","","]"),
+AttrSuggestionStyle::Attribute(AttrStyle::Inner) => ("#![","","]"),
+AttrSuggestionStyle::Macro => ("","!",""),
+AttrSuggestionStyle::EmbeddedAttribute => ("","",""),
 };
+
+letmut suggestions = vec![];
+
 ifself.word{
+debug_assert!(macro_call.is_empty(),"Macro suggestions use list style");
  suggestions.push(format!("{start}{name}{end}"));
 }
 ifletSome(descr) = self.list{
 for descr in descr {
- suggestions.push(format!("{start}{name}({descr}){end}"));
+ suggestions.push(format!("{start}{name}{macro_call}({descr}){end}"));
 }
 }
  suggestions.extend(self.one_of.iter().map(|&word| format!("{start}{name}({word}){end}")));
 ifletSome(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}"));
 }

compiler/rustc_feature/src/lib.rs

@@ -129,9 +129,10 @@ pub fn find_feature_issue(feature: Symbol, issue: GateIssue) -> Option<NonZero<u
 
 pubuse accepted::ACCEPTED_LANG_FEATURES;
 pubuse builtin_attrs::{
-AttributeDuplicates,AttributeGate,AttributeSafety,AttributeTemplate,AttributeType,
-BUILTIN_ATTRIBUTE_MAP,BUILTIN_ATTRIBUTES,BuiltinAttribute,GatedCfg, encode_cross_crate,
- find_gated_cfg, is_builtin_attr_name, is_stable_diagnostic_attribute, is_valid_for_get_attr,
+AttrSuggestionStyle,AttributeDuplicates,AttributeGate,AttributeSafety,AttributeTemplate,
+AttributeType,BUILTIN_ATTRIBUTE_MAP,BUILTIN_ATTRIBUTES,BuiltinAttribute,GatedCfg,
+ encode_cross_crate, find_gated_cfg, is_builtin_attr_name, is_stable_diagnostic_attribute,
+ is_valid_for_get_attr,
 };
 pubuse removed::REMOVED_LANG_FEATURES;
 pubuse unstable::{

compiler/rustc_hir_analysis/src/check/check.rs

@@ -1542,22 +1542,10 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
 
 let typing_env = ty::TypingEnv::non_body_analysis(tcx, adt.did());
 // For each field, figure out if it has "trivial" layout (i.e., is a 1-ZST).
-// Even some 1-ZST fields are not allowed though, if they have `non_exhaustive` or private
-// fields or `repr(C)`. We call those fields "unsuited".
 structFieldInfo<'tcx>{
 span:Span,
 trivial:bool,
-unsuited:Option<UnsuitedInfo<'tcx>>,
-}
-structUnsuitedInfo<'tcx>{
-/// The source of the problem, a type that is found somewhere within the field type.
 ty:Ty<'tcx>,
-reason:UnsuitedReason,
-}
-enumUnsuitedReason{
-NonExhaustive,
-PrivateField,
-ReprC,
 }
 
 let field_infos = adt.all_fields().map(|field| {
@@ -1566,60 +1554,7 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
 // We are currently checking the type this field came from, so it must be local
 let span = tcx.hir_span_if_local(field.did).unwrap();
 let trivial = layout.is_ok_and(|layout| layout.is_1zst());
-if !trivial {
-// No need to even compute `unsuited`.
-returnFieldInfo{ span, trivial,unsuited:None};
-}
-
-fncheck_unsuited<'tcx>(
-tcx:TyCtxt<'tcx>,
-typing_env: ty::TypingEnv<'tcx>,
-ty:Ty<'tcx>,
-) -> ControlFlow<UnsuitedInfo<'tcx>>{
-// We can encounter projections during traversal, so ensure the type is normalized.
-let ty = tcx.try_normalize_erasing_regions(typing_env, ty).unwrap_or(ty);
-match ty.kind(){
- ty::Tuple(list) => list.iter().try_for_each(|t| check_unsuited(tcx, typing_env, t)),
- ty::Array(ty, _) => check_unsuited(tcx, typing_env,*ty),
- ty::Adt(def, args) => {
-if !def.did().is_local()
- && !find_attr!(
- tcx.get_all_attrs(def.did()),
-AttributeKind::PubTransparent(_)
-)
-{
-let non_exhaustive = def.is_variant_list_non_exhaustive()
- || def
-.variants()
-.iter()
-.any(ty::VariantDef::is_field_list_non_exhaustive);
-let has_priv = def.all_fields().any(|f| !f.vis.is_public());
-if non_exhaustive || has_priv {
-returnControlFlow::Break(UnsuitedInfo{
- ty,
-reason:if non_exhaustive {
-UnsuitedReason::NonExhaustive
-}else{
-UnsuitedReason::PrivateField
-},
-});
-}
-}
-if def.repr().c(){
-returnControlFlow::Break(UnsuitedInfo{
- ty,
-reason:UnsuitedReason::ReprC,
-});
-}
- def.all_fields()
-.map(|field| field.ty(tcx, args))
-.try_for_each(|t| check_unsuited(tcx, typing_env, t))
-}
- _ => ControlFlow::Continue(()),
-}
-}
-
-FieldInfo{ span, trivial,unsuited:check_unsuited(tcx, typing_env, ty).break_value()}
+FieldInfo{ span, trivial, ty }
 });
 
 let non_trivial_fields = field_infos
@@ -1637,10 +1572,63 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
 return;
 }
 
+// Even some 1-ZST fields are not allowed though, if they have `non_exhaustive` or private
+// fields or `repr(C)`. We call those fields "unsuited".
+structUnsuitedInfo<'tcx>{
+/// The source of the problem, a type that is found somewhere within the field type.
+ty:Ty<'tcx>,
+reason:UnsuitedReason,
+}
+enumUnsuitedReason{
+NonExhaustive,
+PrivateField,
+ReprC,
+}
+
+fncheck_unsuited<'tcx>(
+tcx:TyCtxt<'tcx>,
+typing_env: ty::TypingEnv<'tcx>,
+ty:Ty<'tcx>,
+) -> ControlFlow<UnsuitedInfo<'tcx>>{
+// We can encounter projections during traversal, so ensure the type is normalized.
+let ty = tcx.try_normalize_erasing_regions(typing_env, ty).unwrap_or(ty);
+match ty.kind(){
+ ty::Tuple(list) => list.iter().try_for_each(|t| check_unsuited(tcx, typing_env, t)),
+ ty::Array(ty, _) => check_unsuited(tcx, typing_env,*ty),
+ ty::Adt(def, args) => {
+if !def.did().is_local()
+ && !find_attr!(tcx.get_all_attrs(def.did()),AttributeKind::PubTransparent(_))
+{
+let non_exhaustive = def.is_variant_list_non_exhaustive()
+ || def.variants().iter().any(ty::VariantDef::is_field_list_non_exhaustive);
+let has_priv = def.all_fields().any(|f| !f.vis.is_public());
+if non_exhaustive || has_priv {
+returnControlFlow::Break(UnsuitedInfo{
+ ty,
+reason:if non_exhaustive {
+UnsuitedReason::NonExhaustive
+}else{
+UnsuitedReason::PrivateField
+},
+});
+}
+}
+if def.repr().c(){
+returnControlFlow::Break(UnsuitedInfo{ ty,reason:UnsuitedReason::ReprC});
+}
+ def.all_fields()
+.map(|field| field.ty(tcx, args))
+.try_for_each(|t| check_unsuited(tcx, typing_env, t))
+}
+ _ => ControlFlow::Continue(()),
+}
+}
+
 letmut prev_unsuited_1zst = false;
 for field in field_infos {
-ifletSome(unsuited) = field.unsuited{
-assert!(field.trivial);
+if field.trivial
+ && letSome(unsuited) = check_unsuited(tcx, typing_env, field.ty).break_value()
+{
 // If there are any non-trivial fields, then there can be no non-exhaustive 1-zsts.
 // Otherwise, it's only an issue if there's >1 non-exhaustive 1-zst.
 if non_trivial_count > 0 || prev_unsuited_1zst {

compiler/rustc_metadata/src/rmeta/table.rs

@@ -55,8 +55,10 @@ impl IsDefault for UnusedGenericParams {
 
 /// Helper trait, for encoding to, and decoding from, a fixed number of bytes.
 /// Used mainly for Lazy positions and lengths.
-/// Unchecked invariant: `Self::default()` should encode as `[0; BYTE_LEN]`,
+///
+/// Invariant: `Self::default()` should encode as `[0; BYTE_LEN]`,
 /// but this has no impact on safety.
+/// In debug builds, this invariant is checked in `[TableBuilder::set]`
 pub(super)traitFixedSizeEncoding:IsDefault{
 /// This should be `[u8; BYTE_LEN]`;
 /// Cannot use an associated `const BYTE_LEN: usize` instead due to const eval limitations.
@@ -432,6 +434,13 @@ impl<I: Idx, const N: usize, T: FixedSizeEncoding<ByteArray = [u8; N]>> TableBui
 /// arises in the future then a new method (e.g. `clear` or `reset`) will need to be introduced
 /// for doing that explicitly.
 pub(crate)fnset(&mutself,i:I,value:T){
+#[cfg(debug_assertions)]
+{
+debug_assert!(
+T::from_bytes(&[0;N]).is_default(),
+"expected all-zeroes to decode to the default value, as per the invariant of FixedSizeEncoding"
+);
+}
 if !value.is_default(){
 // FIXME(eddyb) investigate more compact encodings for sparse tables.
 // On the PR @michaelwoerister mentioned: