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_data_structures/src/attributes.rs

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

compiler/rustc_attr_data_structures/src/encode_cross_crate.rs

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

compiler/rustc_attr_parsing/src/attributes/debuginfo.rs

@@ -0,0 +1,12 @@
+use rustc_attr_data_structures::AttributeKind;
+use rustc_span::{Span, Symbol, sym};
+
+use crate::attributes::{NoArgsAttributeParser, OnDuplicate};
+use crate::context::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 CREATE: fn(Span) -> AttributeKind = AttributeKind::DebuginfoTransparent;
+}

compiler/rustc_attr_parsing/src/attributes/mod.rs

@@ -30,6 +30,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

@@ -22,6 +22,7 @@ use crate::attributes::codegen_attrs::{
     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};
@@ -167,6 +168,7 @@ attribute_parsers!(
         Single<WithoutArgs<ConstContinueParser>>,
         Single<WithoutArgs<ConstStabilityIndirectParser>>,
         Single<WithoutArgs<ConstTraitParser>>,
+        Single<WithoutArgs<DebuginfoTransparentParser>>,
         Single<WithoutArgs<DenyExplicitImplParser>>,
         Single<WithoutArgs<DoNotImplementViaObjectParser>>,
         Single<WithoutArgs<ExportStableParser>>,

compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs

@@ -7,6 +7,7 @@ use std::{iter, ptr};
 
 use libc::{c_longlong, c_uint};
 use rustc_abi::{Align, Size};
+use rustc_attr_data_structures::{AttributeKind, find_attr};
 use rustc_codegen_ssa::debuginfo::type_names::{VTableNameKind, cpp_like_debuginfo};
 use rustc_codegen_ssa::traits::*;
 use rustc_hir::def::{CtorKind, DefKind};
@@ -1070,6 +1071,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

@@ -666,6 +666,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

@@ -462,6 +462,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_parse/src/validate_attr.rs

@@ -319,6 +319,7 @@ pub fn check_builtin_meta_item(
                 | sym::no_implicit_prelude
                 | sym::automatically_derived
                 | sym::coverage
+                | sym::debuginfo_transparent
         ) {
             return;
         }

compiler/rustc_passes/src/check_attr.rs

@@ -170,6 +170,14 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         target,
                         Target::Impl { of_trait: true },
                     ),
+                Attribute::Parsed(AttributeKind::DebuginfoTransparent(attr_span)) => self
+                    .check_generic_attr(
+                        hir_id,
+                        sym::debuginfo_transparent,
+                        *attr_span,
+                        target,
+                        Target::Struct,
+                    ),
                 Attribute::Parsed(
                     AttributeKind::Stability {
                         span: attr_span,