Create node Item and AdtDef for anonymous adts

Author: frank-king

compiler/rustc_ast/src/ast.rs

@@ -2093,9 +2093,9 @@ pub enum TyKind {
     /// A tuple (`(A, B, C, D,...)`).
     Tup(ThinVec<P<Ty>>),
     /// An anonymous struct type i.e. `struct { foo: Type }`
-    AnonStruct(ThinVec<FieldDef>),
+    AnonStruct(NodeId, ThinVec<FieldDef>),
     /// An anonymous union type i.e. `union { bar: Type }`
-    AnonUnion(ThinVec<FieldDef>),
+    AnonUnion(NodeId, ThinVec<FieldDef>),
     /// A path (`module::module::...::Type`), optionally
     /// "qualified", e.g., `<Vec<T> as SomeTrait>::SomeType`.
     ///

compiler/rustc_ast/src/mut_visit.rs

@@ -509,7 +509,8 @@ pub fn noop_visit_ty<T: MutVisitor>(ty: &mut P<Ty>, vis: &mut T) {
             visit_vec(bounds, |bound| vis.visit_param_bound(bound));
         }
         TyKind::MacCall(mac) => vis.visit_mac_call(mac),
-        TyKind::AnonStruct(fields) | TyKind::AnonUnion(fields) => {
+        TyKind::AnonStruct(id, fields) | TyKind::AnonUnion(id, fields) => {
+            vis.visit_id(id);
             fields.flat_map_in_place(|field| vis.flat_map_field_def(field));
         }
     }

compiler/rustc_ast/src/visit.rs

@@ -438,7 +438,7 @@ pub fn walk_ty<'a, V: Visitor<'a>>(visitor: &mut V, typ: &'a Ty) {
         TyKind::Infer | TyKind::ImplicitSelf | TyKind::Err => {}
         TyKind::MacCall(mac) => visitor.visit_mac_call(mac),
         TyKind::Never | TyKind::CVarArgs => {}
-        TyKind::AnonStruct(ref fields, ..) | TyKind::AnonUnion(ref fields, ..) => {
+        TyKind::AnonStruct(_, ref fields) | TyKind::AnonUnion(_, ref fields) => {
             walk_list!(visitor, visit_field_def, fields)
         }
     }

compiler/rustc_ast_lowering/src/item.rs

@@ -708,7 +708,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
     }
 
-    pub(super) fn lower_field_def(&mut self, (index, f): (usize, &FieldDef)) -> hir::FieldDef<'hir> {
+    pub(super) fn lower_field_def(
+        &mut self,
+        (index, f): (usize, &FieldDef),
+    ) -> hir::FieldDef<'hir> {
         let ty = if let TyKind::Path(qself, path) = &f.ty.kind {
             let t = self.lower_path_ty(
                 &f.ty,

compiler/rustc_ast_lowering/src/lib.rs

@@ -1293,15 +1293,39 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             TyKind::Err => {
                 hir::TyKind::Err(self.tcx.sess.delay_span_bug(t.span, "TyKind::Err lowered"))
             }
-            TyKind::AnonStruct(fields) => {
-                hir::TyKind::AnonStruct(
-                    self.arena.alloc_from_iter(fields.iter().enumerate().map(|f| self.lower_field_def(f))),
-                )
-            }
-            TyKind::AnonUnion(fields) => {
-                hir::TyKind::AnonUnion(
-                    self.arena.alloc_from_iter(fields.iter().enumerate().map(|f| self.lower_field_def(f))),
-                )
+            TyKind::AnonStruct(def_node_id, fields) | TyKind::AnonUnion(def_node_id, fields) => {
+                let def_path_data = match &t.kind {
+                    TyKind::AnonStruct(..) => DefPathData::AnonStruct,
+                    _ => DefPathData::AnonUnion,
+                };
+                let def_id = self.create_def(
+                    self.current_hir_id_owner.def_id,
+                    *def_node_id,
+                    def_path_data,
+                    t.span,
+                );
+                debug!(?def_id);
+                let owner_id = hir::OwnerId { def_id };
+                self.with_hir_id_owner(*def_node_id, |this| {
+                    let fields = this.arena.alloc_from_iter(
+                        fields.iter().enumerate().map(|f| this.lower_field_def(f)),
+                    );
+                    let span = t.span;
+                    let variant_data = hir::VariantData::Struct(fields, false);
+                    let generics = hir::Generics::empty();
+                    let kind = match &t.kind {
+                        TyKind::AnonStruct(..) => hir::ItemKind::Struct(variant_data, generics),
+                        _ => hir::ItemKind::Union(variant_data, generics),
+                    };
+                    hir::OwnerNode::Item(this.arena.alloc(hir::Item {
+                        ident: Ident::empty(),
+                        owner_id,
+                        kind,
+                        span: this.lower_span(span),
+                        vis_span: this.lower_span(span.shrink_to_lo()),
+                    }))
+                });
+                hir::TyKind::AnonAdt(hir::ItemId { owner_id })
             }
             TyKind::Slice(ty) => hir::TyKind::Slice(self.lower_ty(ty, itctx)),
             TyKind::Ptr(mt) => hir::TyKind::Ptr(self.lower_mt(mt, itctx)),

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -219,7 +219,7 @@ impl<'a> AstValidator<'a> {
                     }
                 }
             }
-            TyKind::AnonStruct(ref fields, ..) | TyKind::AnonUnion(ref fields, ..) => {
+            TyKind::AnonStruct(_, ref fields) | TyKind::AnonUnion(_, ref fields) => {
                 walk_list!(self, visit_field_def, fields)
             }
             _ => visit::walk_ty(self, t),

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -1053,11 +1053,11 @@ impl<'a> State<'a> {
                 }
                 self.pclose();
             }
-            ast::TyKind::AnonStruct(fields) => {
+            ast::TyKind::AnonStruct(_, fields) => {
                 self.head("struct");
                 self.print_record_struct_body(&fields, ty.span);
             }
-            ast::TyKind::AnonUnion(fields) => {
+            ast::TyKind::AnonUnion(_, fields) => {
                 self.head("union");
                 self.print_record_struct_body(&fields, ty.span);
             }

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

@@ -338,7 +338,7 @@ fn build_single_variant_union_fields<'ll, 'tcx>(
         enum_type_di_node,
         std::iter::once((
             variant_index,
-            Cow::from(enum_adt_def.variant(variant_index).name_ref().as_str()),
+            Cow::from(enum_adt_def.variant(variant_index).name.as_str()),
         )),
     );
 
@@ -399,7 +399,7 @@ fn build_union_fields_for_enum<'ll, 'tcx>(
         cx,
         enum_type_di_node,
         variant_indices.clone().map(|variant_index| {
-            let variant_name = Cow::from(enum_adt_def.variant(variant_index).name_ref().as_str());
+            let variant_name = Cow::from(enum_adt_def.variant(variant_index).name.as_str());
             (variant_index, variant_name)
         }),
     );

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

@@ -92,7 +92,7 @@ fn build_c_style_enum_di_node<'ll, 'tcx>(
             &compute_debuginfo_type_name(cx.tcx, enum_type_and_layout.ty, false),
             tag_base_type(cx, enum_type_and_layout),
             enum_adt_def.discriminants(cx.tcx).map(|(variant_index, discr)| {
-                let name = Cow::from(enum_adt_def.variant(variant_index).name_ref().as_str());
+                let name = Cow::from(enum_adt_def.variant(variant_index).name.as_str());
                 (name, discr.val)
             }),
             containing_scope,
@@ -263,7 +263,7 @@ fn build_enum_variant_struct_type_di_node<'ll, 'tcx>(
                 enum_type_and_layout.ty,
                 variant_index,
             ),
-            variant_def.name().as_str(),
+            variant_def.name.as_str(),
             // 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),

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

@@ -84,7 +84,7 @@ pub(super) fn build_enum_type_di_node<'ll, 'tcx>(
                 .variant_range()
                 .map(|variant_index| VariantMemberInfo {
                     variant_index,
-                    variant_name: Cow::from(enum_adt_def.variant(variant_index).name_ref().as_str()),
+                    variant_name: Cow::from(enum_adt_def.variant(variant_index).name.as_str()),
                     variant_struct_type_di_node: super::build_enum_variant_struct_type_di_node(
                         cx,
                         enum_type_and_layout,