Refactor type_map::stub parameters

Push span lookup into `type_map::stub` and pass the `DefId` instead of
doing the lookup outside and passing in the location metadata.

Author: mweber15

compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs

@@ -213,8 +213,7 @@ fn build_pointer_or_reference_di_node<'ll, 'tcx>(
                     Stub::Struct,
                     unique_type_id,
                     &ptr_type_debuginfo_name,
-                    unknown_file_metadata(cx),
-                    UNKNOWN_LINE_NUMBER,
+                    None,
                     cx.size_and_align_of(ptr_type),
                     NO_SCOPE_METADATA,
                     DIFlags::FlagZero,
@@ -369,8 +368,7 @@ fn build_dyn_type_di_node<'ll, 'tcx>(
                 Stub::Struct,
                 unique_type_id,
                 &type_name,
-                unknown_file_metadata(cx),
-                UNKNOWN_LINE_NUMBER,
+                None,
                 cx.size_and_align_of(dyn_type),
                 NO_SCOPE_METADATA,
                 DIFlags::FlagZero,
@@ -752,8 +750,7 @@ fn build_foreign_type_di_node<'ll, 'tcx>(
             Stub::Struct,
             unique_type_id,
             &compute_debuginfo_type_name(cx.tcx, t, false),
-            unknown_file_metadata(cx),
-            UNKNOWN_LINE_NUMBER,
+            None,
             cx.size_and_align_of(t),
             Some(get_namespace_for_item(cx, def_id)),
             DIFlags::FlagZero,
@@ -984,24 +981,14 @@ fn build_struct_type_di_node<'ll, 'tcx>(
     let struct_type_and_layout = cx.layout_of(struct_type);
     let variant_def = adt_def.non_enum_variant();
 
-    let tcx = cx.tcx;
-    let struct_span = tcx.def_span(adt_def.did());
-    let (file_metadata, line_number) = if !struct_span.is_dummy() {
-        let loc = cx.lookup_debug_loc(struct_span.lo());
-        (file_metadata(cx, &loc.file), loc.line)
-    } else {
-        (unknown_file_metadata(cx), UNKNOWN_LINE_NUMBER)
-    };
-
     type_map::build_type_with_children(
         cx,
         type_map::stub(
             cx,
             Stub::Struct,
             unique_type_id,
             &compute_debuginfo_type_name(cx.tcx, struct_type, false),
-            file_metadata,
-            line_number,
+            Some(adt_def.did()),
             size_and_align_of(struct_type_and_layout),
             Some(containing_scope),
             DIFlags::FlagZero,
@@ -1112,8 +1099,7 @@ fn build_tuple_type_di_node<'ll, 'tcx>(
             Stub::Struct,
             unique_type_id,
             &type_name,
-            unknown_file_metadata(cx),
-            UNKNOWN_LINE_NUMBER,
+            None,
             size_and_align_of(tuple_type_and_layout),
             NO_SCOPE_METADATA,
             DIFlags::FlagZero,
@@ -1152,23 +1138,14 @@ fn build_closure_env_di_node<'ll, 'tcx>(
     let containing_scope = get_namespace_for_item(cx, def_id);
     let type_name = compute_debuginfo_type_name(cx.tcx, closure_env_type, false);
 
-    let closure_span = cx.tcx.def_span(def_id);
-    let (file_metadata, line_number) = if !closure_span.is_dummy() {
-        let loc = cx.lookup_debug_loc(closure_span.lo());
-        (file_metadata(cx, &loc.file), loc.line)
-    } else {
-        (unknown_file_metadata(cx), UNKNOWN_LINE_NUMBER)
-    };
-
     type_map::build_type_with_children(
         cx,
         type_map::stub(
             cx,
             Stub::Struct,
             unique_type_id,
             &type_name,
-            file_metadata,
-            line_number,
+            Some(def_id),
             cx.size_and_align_of(closure_env_type),
             Some(containing_scope),
             DIFlags::FlagZero,
@@ -1200,8 +1177,7 @@ fn build_union_type_di_node<'ll, 'tcx>(
             Stub::Union,
             unique_type_id,
             &type_name,
-            unknown_file_metadata(cx),
-            UNKNOWN_LINE_NUMBER,
+            Some(union_def_id),
             size_and_align_of(union_ty_and_layout),
             Some(containing_scope),
             DIFlags::FlagZero,
@@ -1387,8 +1363,7 @@ fn build_vtable_type_di_node<'ll, 'tcx>(
             Stub::VTableTy { vtable_holder },
             unique_type_id,
             &vtable_type_name,
-            unknown_file_metadata(cx),
-            UNKNOWN_LINE_NUMBER,
+            None,
             (size, pointer_align),
             NO_SCOPE_METADATA,
             DIFlags::FlagArtificial,

compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/cpp_like.rs

@@ -213,8 +213,7 @@ pub(super) fn build_enum_type_di_node<'ll, 'tcx>(
             type_map::Stub::Union,
             unique_type_id,
             &enum_type_name,
-            unknown_file_metadata(cx),
-            UNKNOWN_LINE_NUMBER,
+            Some(enum_adt_def.did()),
             cx.size_and_align_of(enum_type),
             NO_SCOPE_METADATA,
             DIFlags::FlagZero,
@@ -290,8 +289,7 @@ pub(super) fn build_generator_di_node<'ll, 'tcx>(
             type_map::Stub::Union,
             unique_type_id,
             &generator_type_name,
-            unknown_file_metadata(cx),
-            UNKNOWN_LINE_NUMBER,
+            None,
             size_and_align_of(generator_type_and_layout),
             NO_SCOPE_METADATA,
             DIFlags::FlagZero,
@@ -344,6 +342,7 @@ fn build_single_variant_union_fields<'ll, 'tcx>(
             variant_index,
             Cow::from(enum_adt_def.variant(variant_index).name.as_str()),
         )),
+        enum_adt_def.did(),
     );
 
     let variant_struct_type_wrapper_di_node = build_variant_struct_wrapper_type_di_node(
@@ -406,6 +405,7 @@ fn build_union_fields_for_enum<'ll, 'tcx>(
             let variant_name = Cow::from(enum_adt_def.variant(variant_index).name.as_str());
             (variant_index, variant_name)
         }),
+        enum_adt_def.did(),
     );
 
     let variant_field_infos: SmallVec<VariantFieldInfo<'ll>> = variant_indices
@@ -460,13 +460,15 @@ fn build_variant_names_type_di_node<'ll, 'tcx>(
     cx: &CodegenCx<'ll, 'tcx>,
     containing_scope: &'ll DIType,
     variants: impl Iterator<Item = (VariantIdx, Cow<'tcx, str>)>,
+    enum_def_id: rustc_span::def_id::DefId,
 ) -> &'ll DIType {
     // Create an enumerator for each variant.
     super::build_enumeration_type_di_node(
         cx,
         "VariantNames",
         variant_names_enum_base_type(cx),
         variants.map(|(variant_index, variant_name)| (variant_name, variant_index.as_u32().into())),
+        enum_def_id,
         containing_scope,
     )
 }
@@ -494,8 +496,7 @@ fn build_variant_struct_wrapper_type_di_node<'ll, 'tcx>(
                 variant_index,
             ),
             &variant_struct_wrapper_type_name(variant_index),
-            unknown_file_metadata(cx),
-            UNKNOWN_LINE_NUMBER,
+            None,
             // NOTE: We use size and align of enum_type, not from variant_layout:
             size_and_align_of(enum_or_generator_type_and_layout),
             Some(enum_or_generator_type_di_node),
@@ -697,6 +698,7 @@ fn build_union_fields_for_direct_tag_generator<'ll, 'tcx>(
         variant_range
             .clone()
             .map(|variant_index| (variant_index, GeneratorSubsts::variant_name(variant_index))),
+        generator_def_id,
     );
 
     let discriminants: IndexVec<VariantIdx, DiscrResult> = {

compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/mod.rs

@@ -21,9 +21,9 @@ use crate::{
     common::CodegenCx,
     debuginfo::{
         metadata::{
-            build_field_di_node, build_generic_type_param_di_nodes, type_di_node,
+            build_field_di_node, build_generic_type_param_di_nodes, file_metadata_from_def_id,
+            type_di_node,
             type_map::{self, Stub},
-            unknown_file_metadata, UNKNOWN_LINE_NUMBER,
         },
         utils::{create_DIArray, get_namespace_for_item, DIB},
     },
@@ -93,6 +93,7 @@ fn build_c_style_enum_di_node<'ll, 'tcx>(
                 let name = Cow::from(enum_adt_def.variant(variant_index).name.as_str());
                 (name, discr.val)
             }),
+            enum_adt_def.did(),
             containing_scope,
         ),
         already_stored_in_typemap: false,
@@ -150,6 +151,7 @@ fn build_enumeration_type_di_node<'ll, 'tcx>(
     type_name: &str,
     base_type: Ty<'tcx>,
     enumerators: impl Iterator<Item = (Cow<'tcx, str>, u128)>,
+    def_id: rustc_span::def_id::DefId,
     containing_scope: &'ll DIType,
 ) -> &'ll DIType {
     let is_unsigned = match base_type.kind() {
@@ -173,14 +175,16 @@ fn build_enumeration_type_di_node<'ll, 'tcx>(
         })
         .collect();
 
+    let (file_metadata, line_number) = file_metadata_from_def_id(cx, Some(def_id));
+
     unsafe {
         llvm::LLVMRustDIBuilderCreateEnumerationType(
             DIB(cx),
             containing_scope,
             type_name.as_ptr().cast(),
             type_name.len(),
-            unknown_file_metadata(cx),
-            UNKNOWN_LINE_NUMBER,
+            file_metadata,
+            line_number,
             size.bits(),
             align.bits() as u32,
             create_DIArray(DIB(cx), &enumerator_di_nodes[..]),
@@ -261,8 +265,7 @@ fn build_enum_variant_struct_type_di_node<'ll, 'tcx>(
                 variant_index,
             ),
             variant_def.name.as_str(),
-            unknown_file_metadata(cx),
-            UNKNOWN_LINE_NUMBER,
+            None,
             // NOTE: We use size and align of enum_type, not from variant_layout:
             size_and_align_of(enum_type_and_layout),
             Some(enum_type_di_node),
@@ -345,8 +348,7 @@ pub fn build_generator_variant_struct_type_di_node<'ll, 'tcx>(
             Stub::Struct,
             unique_type_id,
             &variant_name,
-            unknown_file_metadata(cx),
-            UNKNOWN_LINE_NUMBER,
+            None,
             size_and_align_of(generator_type_and_layout),
             Some(generator_type_di_node),
             DIFlags::FlagZero,

compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/native.rs

@@ -72,8 +72,7 @@ pub(super) fn build_enum_type_di_node<'ll, 'tcx>(
             Stub::Struct,
             unique_type_id,
             &enum_type_name,
-            unknown_file_metadata(cx),
-            UNKNOWN_LINE_NUMBER,
+            Some(enum_adt_def.did()),
             size_and_align_of(enum_type_and_layout),
             Some(containing_scope),
             DIFlags::FlagZero,
@@ -152,8 +151,7 @@ pub(super) fn build_generator_di_node<'ll, 'tcx>(
             Stub::Struct,
             unique_type_id,
             &generator_type_name,
-            unknown_file_metadata(cx),
-            UNKNOWN_LINE_NUMBER,
+            None,
             size_and_align_of(generator_type_and_layout),
             Some(containing_scope),
             DIFlags::FlagZero,

compiler/rustc_codegen_llvm/src/debuginfo/metadata/type_map.rs

@@ -16,11 +16,11 @@ use crate::{
     debuginfo::utils::{create_DIArray, debug_context, DIB},
     llvm::{
         self,
-        debuginfo::{DIFile, DIFlags, DIScope, DIType},
+        debuginfo::{DIFlags, DIScope, DIType},
     },
 };
 
-use super::SmallVec;
+use super::{file_metadata, unknown_file_metadata, SmallVec, UNKNOWN_LINE_NUMBER};
 
 mod private {
     // This type cannot be constructed outside of this module because
@@ -183,15 +183,26 @@ pub(super) fn stub<'ll, 'tcx>(
     kind: Stub<'ll>,
     unique_type_id: UniqueTypeId<'tcx>,
     name: &str,
-    file_metadata: &'ll DIFile,
-    line_number: u32,
+    def_id: Option<rustc_span::def_id::DefId>,
     (size, align): (Size, Align),
     containing_scope: Option<&'ll DIScope>,
     flags: DIFlags,
 ) -> StubInfo<'ll, 'tcx> {
     let empty_array = create_DIArray(DIB(cx), &[]);
     let unique_type_id_str = unique_type_id.generate_unique_id_string(cx.tcx);
 
+    let (file_metadata, line_number) = if let Some(def_id) = def_id {
+        let span = cx.tcx.def_span(def_id);
+        if !span.is_dummy() {
+            let loc = cx.lookup_debug_loc(span.lo());
+            (file_metadata(cx, &loc.file), loc.line)
+        } else {
+            (unknown_file_metadata(cx), UNKNOWN_LINE_NUMBER)
+        }
+    } else {
+        (unknown_file_metadata(cx), UNKNOWN_LINE_NUMBER)
+    };
+
     let metadata = match kind {
         Stub::Struct | Stub::VTableTy { .. } => {
             let vtable_holder = match kind {

tests/codegen/issue-98678.rs

@@ -3,12 +3,31 @@
 // compile-flags: -C debuginfo=2
 #![crate_type = "lib"]
 
-// CHECK: ![[#FILE:]] = !DIFile({{.*}}filename:{{.*}}src/test/codegen/issue-98678.rs{{".*}})
+// The use of CHECK-DAG here is because the C++-like enum is emitted before the `DIFile` node
+
+// CHECK-DAG: ![[#FILE:]] = !DIFile({{.*}}filename:{{.*}}src/test/codegen/issue-98678.rs{{".*}})
+
+// CHECK-DAG: !DICompositeType({{.*"}}MyCppLikeEnum{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 2]],
+#[repr(C)]
+pub enum MyCppLikeEnum {
+    One,
+}
 
 // CHECK: !DICompositeType({{.*"}}MyType{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
 pub struct MyType;
 
-pub fn foo(_: MyType) {
+// CHECK: !DICompositeType({{.*"}}MyUnion{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
+pub union MyUnion {
+    i: i32, // TODO fields are still wrong
+    f: f32,
+}
+
+// CHECK: !DICompositeType({{.*"}}MyNativeEnum{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
+pub enum MyNativeEnum {
+    One,
+}
+
+pub fn foo(_: MyType, _: MyUnion, _: MyNativeEnum, _: MyCppLikeEnum) {
     // CHECK: !DICompositeType({{.*"[{]}}closure_env#0{{[}]".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
     let closure = |x| x;
     closure(0);