Rustdoc-Json: Put fields for enum typle variants in their own item.

Closes #100587
Closes #92945

Author: aDotInTheVoid

src/etc/check_missing_items.py

@@ -143,11 +143,7 @@ def check_type(ty):
             set(item["inner"]["variants"]) | set(item["inner"]["impls"])
         ) - visited
     elif item["kind"] == "variant":
-        if item["inner"]["variant_kind"] == "tuple":
-            for ty in item["inner"]["variant_inner"]:
-                check_type(ty)
-        elif item["inner"]["variant_kind"] == "struct":
-            work_list |= set(item["inner"]["variant_inner"]) - visited
+        work_list |= set(item["inner"]["fields"]) - visited
     elif item["kind"] in ("function", "method"):
         check_generics(item["inner"]["generics"])
         check_decl(item["inner"]["decl"])

src/librustdoc/json/conversions.rs

@@ -238,7 +238,7 @@ fn from_clean_item(item: clean::Item, tcx: TyCtxt<'_>) -> ItemEnum {
 
     match *item.kind {
         ModuleItem(m) => {
-            ItemEnum::Module(Module { is_crate, items: ids(m.items, tcx), is_stripped: false })
+            ItemEnum::Module(Module { is_crate, items: ids(&m.items, tcx), is_stripped: false })
         }
         ImportItem(i) => ItemEnum::Import(i.into_tcx(tcx)),
         StructItem(s) => ItemEnum::Struct(s.into_tcx(tcx)),
@@ -282,7 +282,7 @@ fn from_clean_item(item: clean::Item, tcx: TyCtxt<'_>) -> ItemEnum {
             match *inner {
                 ModuleItem(m) => ItemEnum::Module(Module {
                     is_crate,
-                    items: ids(m.items, tcx),
+                    items: ids(&m.items, tcx),
                     is_stripped: true,
                 }),
                 // `convert_item` early returns `None` for stripped items we're not including
@@ -301,10 +301,10 @@ impl FromWithTcx<clean::Struct> for Struct {
         let fields_stripped = struct_.has_stripped_entries();
         let clean::Struct { struct_type, generics, fields } = struct_;
         Struct {
-            struct_type: from_ctor_kind(struct_type),
+            kind: from_ctor_kind(struct_type),
             generics: generics.into_tcx(tcx),
             fields_stripped,
-            fields: ids(fields, tcx),
+            fields: ids(&fields, tcx),
             impls: Vec::new(), // Added in JsonRenderer::item
         }
     }
@@ -317,17 +317,17 @@ impl FromWithTcx<clean::Union> for Union {
         Union {
             generics: generics.into_tcx(tcx),
             fields_stripped,
-            fields: ids(fields, tcx),
+            fields: ids(&fields, tcx),
             impls: Vec::new(), // Added in JsonRenderer::item
         }
     }
 }
 
-pub(crate) fn from_ctor_kind(struct_type: CtorKind) -> StructType {
+pub(crate) fn from_ctor_kind(struct_type: CtorKind) -> StructKind {
     match struct_type {
-        CtorKind::Fictive => StructType::Plain,
-        CtorKind::Fn => StructType::Tuple,
-        CtorKind::Const => StructType::Unit,
+        CtorKind::Fictive => StructKind::Struct,
+        CtorKind::Fn => StructKind::Tuple,
+        CtorKind::Const => StructKind::Unit,
     }
 }
 
@@ -551,7 +551,7 @@ impl FromWithTcx<clean::Trait> for Trait {
         Trait {
             is_auto,
             is_unsafe,
-            items: ids(items, tcx),
+            items: ids(&items, tcx),
             generics: generics.into_tcx(tcx),
             bounds: bounds.into_tcx(tcx),
             implementations: Vec::new(), // Added in JsonRenderer::item
@@ -591,7 +591,7 @@ impl FromWithTcx<clean::Impl> for Impl {
                 .collect(),
             trait_: trait_.map(|path| path.into_tcx(tcx)),
             for_: for_.into_tcx(tcx),
-            items: ids(items, tcx),
+            items: ids(&items, tcx),
             negative: negative_polarity,
             synthetic,
             blanket_impl: blanket_impl.map(|x| x.into_tcx(tcx)),
@@ -634,42 +634,28 @@ impl FromWithTcx<clean::Enum> for Enum {
         Enum {
             generics: generics.into_tcx(tcx),
             variants_stripped,
-            variants: ids(variants, tcx),
+            variants: ids(&variants, tcx),
             impls: Vec::new(), // Added in JsonRenderer::item
         }
     }
 }
 
-impl FromWithTcx<clean::VariantStruct> for Struct {
-    fn from_tcx(struct_: clean::VariantStruct, tcx: TyCtxt<'_>) -> Self {
-        let fields_stripped = struct_.has_stripped_entries();
-        let clean::VariantStruct { struct_type, fields } = struct_;
-        Struct {
-            struct_type: from_ctor_kind(struct_type),
-            generics: Generics { params: vec![], where_predicates: vec![] },
-            fields_stripped,
-            fields: ids(fields, tcx),
-            impls: Vec::new(),
-        }
-    }
-}
-
 impl FromWithTcx<clean::Variant> for Variant {
     fn from_tcx(variant: clean::Variant, tcx: TyCtxt<'_>) -> Self {
         use clean::Variant::*;
+
         match variant {
-            CLike => Variant::Plain,
-            Tuple(fields) => Variant::Tuple(
-                fields
-                    .into_iter()
-                    .filter_map(|f| match *f.kind {
-                        clean::StructFieldItem(ty) => Some(ty.into_tcx(tcx)),
-                        clean::StrippedItem(_) => None,
-                        _ => unreachable!(),
-                    })
-                    .collect(),
-            ),
-            Struct(s) => Variant::Struct(ids(s.fields, tcx)),
+            CLike => Variant { kind: StructKind::Unit, fields: Vec::new(), fields_stripped: false },
+            Tuple(fields) => Variant {
+                kind: StructKind::Tuple,
+                fields: ids(&fields, tcx),
+                fields_stripped: fields.iter().any(|i| i.is_stripped()),
+            },
+            Struct(s) => Variant {
+                kind: StructKind::Struct,
+                fields: ids(&s.fields, tcx),
+                fields_stripped: s.has_stripped_entries(),
+            },
         }
     }
 }
@@ -773,7 +759,7 @@ impl FromWithTcx<ItemType> for ItemKind {
     }
 }
 
-fn ids(items: impl IntoIterator<Item = clean::Item>, tcx: TyCtxt<'_>) -> Vec<Id> {
+fn ids<'a>(items: impl IntoIterator<Item = &'a clean::Item>, tcx: TyCtxt<'_>) -> Vec<Id> {
     items
         .into_iter()
         .filter(|x| !x.is_stripped() && !x.is_keyword())

src/rustdoc-json-types/lib.rs

@@ -9,7 +9,7 @@ use std::path::PathBuf;
 use serde::{Deserialize, Serialize};
 
 /// rustdoc format-version.
-pub const FORMAT_VERSION: u32 = 18;
+pub const FORMAT_VERSION: u32 = 19;
 
 /// A `Crate` is the root of the emitted JSON blob. It contains all type/documentation information
 /// about the language items in the local crate, as well as info about external items to allow
@@ -289,7 +289,7 @@ pub struct Union {
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub struct Struct {
-    pub struct_type: StructType,
+    pub kind: StructKind,
     pub generics: Generics,
     pub fields_stripped: bool,
     pub fields: Vec<Id>,
@@ -305,18 +305,16 @@ pub struct Enum {
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-#[serde(tag = "variant_kind", content = "variant_inner")]
-pub enum Variant {
-    Plain,
-    Tuple(Vec<Type>),
-    Struct(Vec<Id>),
+pub struct Variant {
+    pub kind: StructKind,
+    pub fields: Vec<Id>,
+    pub fields_stripped: bool,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
-pub enum StructType {
-    Plain,
+pub enum StructKind {
+    Struct,
     Tuple,
     Unit,
 }

src/rustdoc-json-types/tests.rs

@@ -3,7 +3,7 @@ use super::*;
 #[test]
 fn test_struct_info_roundtrip() {
     let s = ItemEnum::Struct(Struct {
-        struct_type: StructType::Plain,
+        kind: StructKind::Struct,
         generics: Generics { params: vec![], where_predicates: vec![] },
         fields_stripped: false,
         fields: vec![],

src/test/rustdoc-json/enum_variant_hidden.rs

@@ -5,8 +5,9 @@
 
 // @has "$.index[*][?(@.name=='ParseError')]"
 // @has "$.index[*][?(@.name=='UnexpectedEndTag')]"
-// @is "$.index[*][?(@.name=='UnexpectedEndTag')].inner.variant_kind" '"tuple"'
-// @is "$.index[*][?(@.name=='UnexpectedEndTag')].inner.variant_inner" []
+// @is "$.index[*][?(@.name=='UnexpectedEndTag')].inner.kind" '"tuple"'
+// @is "$.index[*][?(@.name=='UnexpectedEndTag')].inner.fields" []
+// @is "$.index[*][?(@.name=='UnexpectedEndTag')].inner.fields_stripped" true
 
 pub enum ParseError {
     UnexpectedEndTag(#[doc(hidden)] u32),

src/test/rustdoc-json/enums/variant_struct.rs

@@ -1,7 +1,7 @@
 // @has "$.index[*][?(@.name=='EnumStruct')].visibility" \"public\"
 // @has "$.index[*][?(@.name=='EnumStruct')].kind" \"enum\"
 pub enum EnumStruct {
-    // @has "$.index[*][?(@.name=='VariantS')].inner.variant_kind" \"struct\"
+    // @has "$.index[*][?(@.name=='VariantS')].inner.kind" \"struct\"
     // @has "$.index[*][?(@.name=='x')].kind" \"struct_field\"
     // @has "$.index[*][?(@.name=='y')].kind" \"struct_field\"
     VariantS {

src/test/rustdoc-json/enums/variant_tuple_struct.rs

@@ -1,7 +1,7 @@
 // @has "$.index[*][?(@.name=='EnumTupleStruct')].visibility" \"public\"
 // @has "$.index[*][?(@.name=='EnumTupleStruct')].kind" \"enum\"
 pub enum EnumTupleStruct {
-    // @has "$.index[*][?(@.name=='VariantA')].inner.variant_kind" \"tuple\"
+    // @has "$.index[*][?(@.name=='VariantA')].inner.kind" \"tuple\"
     // @has "$.index[*][?(@.name=='0')].kind" \"struct_field\"
     // @has "$.index[*][?(@.name=='1')].kind" \"struct_field\"
     VariantA(u32, String),

src/test/rustdoc-json/nested.rs

@@ -17,7 +17,7 @@ pub mod l1 {
     pub mod l3 {
 
         // @is "$.index[*][?(@.name=='L4')].kind" \"struct\"
-        // @is "$.index[*][?(@.name=='L4')].inner.struct_type" \"unit\"
+        // @is "$.index[*][?(@.name=='L4')].inner.kind" \"unit\"
         // @set l4_id = "$.index[*][?(@.name=='L4')].id"
         // @ismany "$.index[*][?(@.name=='l3')].inner.items[*]" $l4_id
         pub struct L4;

src/test/rustdoc-json/structs/plain_empty.rs

@@ -1,6 +1,6 @@
 // @has "$.index[*][?(@.name=='PlainEmpty')].visibility" \"public\"
 // @has "$.index[*][?(@.name=='PlainEmpty')].kind" \"struct\"
-// @has "$.index[*][?(@.name=='PlainEmpty')].inner.struct_type" \"plain\"
+// @has "$.index[*][?(@.name=='PlainEmpty')].inner.kind" \"struct\"
 // @has "$.index[*][?(@.name=='PlainEmpty')].inner.fields_stripped" false
 // @has "$.index[*][?(@.name=='PlainEmpty')].inner.fields" []
 pub struct PlainEmpty {}

src/test/rustdoc-json/structs/tuple.rs

@@ -1,5 +1,5 @@
 // @has "$.index[*][?(@.name=='Tuple')].visibility" \"public\"
 // @has "$.index[*][?(@.name=='Tuple')].kind" \"struct\"
-// @has "$.index[*][?(@.name=='Tuple')].inner.struct_type" \"tuple\"
+// @has "$.index[*][?(@.name=='Tuple')].inner.kind" \"tuple\"
 // @has "$.index[*][?(@.name=='Tuple')].inner.fields_stripped" true
 pub struct Tuple(u32, String);