Add debuginfo_transparent attribute for structs

This attribute causes the struct to be unwrapped at the debuginfo level
the same way that repr(transparent) unwraps it at the ABI level. This is
useful for preventing types like NonNull and Unique from making the
debuginfo harder to read when pretty printers aren't used.

Author: bjorn3

compiler/rustc_attr_parsing/src/attributes/debuginfo.rs

@@ -0,0 +1,15 @@
+use rustc_hir::Target;
+use rustc_hir::attrs::AttributeKind;
+use rustc_span::{Span, Symbol, sym};
+
+use crate::attributes::{NoArgsAttributeParser, OnDuplicate};
+use crate::context::MaybeWarn::Allow;
+use crate::context::{AllowedTargets, Stage};
+
+pub(crate) struct DebuginfoTransparentParser;
+impl<S: Stage> NoArgsAttributeParser<S> for DebuginfoTransparentParser {
+    const PATH: &[Symbol] = &[sym::debuginfo_transparent];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Struct)]);
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::DebuginfoTransparent;
+}

compiler/rustc_attr_parsing/src/attributes/mod.rs

@@ -31,6 +31,7 @@ pub(crate) mod cfg;
 pub(crate) mod cfg_old;
 pub(crate) mod codegen_attrs;
 pub(crate) mod confusables;
+pub(crate) mod debuginfo;
 pub(crate) mod deprecation;
 pub(crate) mod dummy;
 pub(crate) mod inline;

compiler/rustc_attr_parsing/src/context.rs

@@ -25,6 +25,7 @@ use crate::attributes::codegen_attrs::{
     TargetFeatureParser, TrackCallerParser, UsedParser,
 };
 use crate::attributes::confusables::ConfusablesParser;
+use crate::attributes::debuginfo::DebuginfoTransparentParser;
 use crate::attributes::deprecation::DeprecationParser;
 use crate::attributes::dummy::DummyParser;
 use crate::attributes::inline::{InlineParser, RustcForceInlineParser};
@@ -199,6 +200,7 @@ attribute_parsers!(
         Single<WithoutArgs<ConstStabilityIndirectParser>>,
         Single<WithoutArgs<ConstTraitParser>>,
         Single<WithoutArgs<CoroutineParser>>,
+        Single<WithoutArgs<DebuginfoTransparentParser>>,
         Single<WithoutArgs<DenyExplicitImplParser>>,
         Single<WithoutArgs<DoNotImplementViaObjectParser>>,
         Single<WithoutArgs<ExportStableParser>>,

compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs

@@ -9,8 +9,10 @@ use libc::{c_longlong, c_uint};
 use rustc_abi::{Align, Size};
 use rustc_codegen_ssa::debuginfo::type_names::{VTableNameKind, cpp_like_debuginfo};
 use rustc_codegen_ssa::traits::*;
+use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def::{CtorKind, DefKind};
 use rustc_hir::def_id::{DefId, LOCAL_CRATE};
+use rustc_hir::find_attr;
 use rustc_middle::bug;
 use rustc_middle::ty::layout::{
     HasTypingEnv, LayoutOf, TyAndLayout, WIDE_PTR_ADDR, WIDE_PTR_EXTRA,
@@ -1070,6 +1072,16 @@ fn build_struct_type_di_node<'ll, 'tcx>(
         None
     };
 
+    if find_attr!(cx.tcx.get_all_attrs(adt_def.did()), AttributeKind::DebuginfoTransparent(..)) {
+        let ty = struct_type_and_layout.non_1zst_field(cx).unwrap().1.ty;
+
+        let di_node = type_di_node(cx, ty);
+
+        return_if_di_node_created_in_meantime!(cx, unique_type_id);
+
+        return DINodeCreationResult::new(di_node, false);
+    }
+
     type_map::build_type_with_children(
         cx,
         type_map::stub(

compiler/rustc_feature/src/builtin_attrs.rs

@@ -880,6 +880,11 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         EncodeCrossCrate::No, loop_match, experimental!(loop_match)
     ),
 
+    gated!(
+        debuginfo_transparent, Normal, template!(Word), WarnFollowing,
+        EncodeCrossCrate::Yes, debuginfo_attrs, experimental!(debuginfo_transparent)
+    ),
+
     // ==========================================================================
     // Internal attributes: Stability, deprecation, and unsafe:
     // ==========================================================================

compiler/rustc_feature/src/unstable.rs

@@ -459,6 +459,8 @@ declare_features! (
     (unstable, custom_inner_attributes, "1.30.0", Some(54726)),
     /// Allows custom test frameworks with `#![test_runner]` and `#[test_case]`.
     (unstable, custom_test_frameworks, "1.30.0", Some(50297)),
+    /// Allows `debuginfo_*` attributes.
+    (unstable, debuginfo_attrs, "CURRENT_RUSTC_VERSION", None),
     /// Allows declarative macros 2.0 (`macro`).
     (unstable, decl_macro, "1.17.0", Some(39412)),
     /// Allows the use of default values on struct definitions and the construction of struct

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -324,6 +324,9 @@ pub enum AttributeKind {
     /// Represents `#[coverage(..)]`.
     Coverage(Span, CoverageAttrKind),
 
+    /// Represents `#[debuginfo_transparent]`.
+    DebuginfoTransparent(Span),
+
     ///Represents `#[rustc_deny_explicit_impl]`.
     DenyExplicitImpl(Span),
 

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -31,6 +31,7 @@ impl AttributeKind {
             ConstTrait(..) => No,
             Coroutine(..) => No,
             Coverage(..) => No,
+            DebuginfoTransparent { .. } => Yes,
             DenyExplicitImpl(..) => No,
             Deprecation { .. } => Yes,
             DoNotImplementViaObject(..) => No,

compiler/rustc_passes/messages.ftl

@@ -83,6 +83,10 @@ passes_dead_codes =
        }
     } never {$participle}
 
+passes_debuginfo_transparent =
+    attribute should be applied to `#[repr(transparent)]` types
+    .label = not a `#[repr(transparent)]` type
+
 passes_debug_visualizer_invalid =
     invalid argument
     .note_1 = expected: `natvis_file = "..."`

compiler/rustc_passes/src/check_attr.rs

@@ -138,6 +138,9 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 &Attribute::Parsed(AttributeKind::TypeConst(attr_span)) => {
                     self.check_type_const(hir_id, attr_span, target)
                 }
+                &Attribute::Parsed(AttributeKind::DebuginfoTransparent(attr_span)) => {
+                    self.check_debuginfo_transparent(attr_span, span, attrs)
+                },
                 Attribute::Parsed(
                     AttributeKind::Stability {
                         span: attr_span,
@@ -2015,6 +2018,14 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
     }
 
+    fn check_debuginfo_transparent(&self, attr_span: Span, span: Span, attrs: &[Attribute]) {
+        if !find_attr!(attrs, AttributeKind::Repr { reprs, .. } => reprs.iter().any(|(r, _)| r == &ReprAttr::ReprTransparent))
+            .unwrap_or(false)
+        {
+            self.dcx().emit_err(errors::DebuginfoTransparent { span, attr_span });
+        }
+    }
+
     fn check_rustc_pub_transparent(&self, attr_span: Span, span: Span, attrs: &[Attribute]) {
         if !find_attr!(attrs, AttributeKind::Repr { reprs, .. } => reprs.iter().any(|(r, _)| r == &ReprAttr::ReprTransparent))
             .unwrap_or(false)