Remove Item::kind, use tagged enum. Rename variants to match

src/librustdoc/json/conversions.rs

@@ -23,7 +23,6 @@ use std::collections::HashSet;
 
 impl JsonRenderer<'_> {
     pub(super) fn convert_item(&self, item: clean::Item) -> Option<Item> {
-        let item_type = ItemType::from(&item);
         let deprecation = item.deprecation(self.tcx);
         let clean::Item { source, name, attrs, kind, visibility, def_id } = item;
         let inner = match *kind {
@@ -50,7 +49,6 @@ impl JsonRenderer<'_> {
                 .map(rustc_ast_pretty::pprust::attribute_to_string)
                 .collect(),
             deprecation: deprecation.map(from_deprecation),
-            kind: item_type.into(),
             inner,
         })
     }
@@ -154,38 +152,38 @@ crate fn from_def_id(did: DefId) -> Id {
 fn from_clean_item_kind(item: clean::ItemKind, tcx: TyCtxt<'_>, name: &Option<Symbol>) -> ItemEnum {
     use clean::ItemKind::*;
     match item {
-        ModuleItem(m) => ItemEnum::ModuleItem(m.into()),
-        ImportItem(i) => ItemEnum::ImportItem(i.into()),
-        StructItem(s) => ItemEnum::StructItem(s.into()),
-        UnionItem(u) => ItemEnum::UnionItem(u.into()),
-        StructFieldItem(f) => ItemEnum::StructFieldItem(f.into()),
-        EnumItem(e) => ItemEnum::EnumItem(e.into()),
-        VariantItem(v) => ItemEnum::VariantItem(v.into()),
-        FunctionItem(f) => ItemEnum::FunctionItem(f.into()),
-        ForeignFunctionItem(f) => ItemEnum::FunctionItem(f.into()),
-        TraitItem(t) => ItemEnum::TraitItem(t.into()),
-        TraitAliasItem(t) => ItemEnum::TraitAliasItem(t.into()),
-        MethodItem(m, _) => ItemEnum::MethodItem(from_function_method(m, true)),
-        TyMethodItem(m) => ItemEnum::MethodItem(from_function_method(m, false)),
-        ImplItem(i) => ItemEnum::ImplItem(i.into()),
-        StaticItem(s) => ItemEnum::StaticItem(from_clean_static(s, tcx)),
-        ForeignStaticItem(s) => ItemEnum::StaticItem(from_clean_static(s, tcx)),
-        ForeignTypeItem => ItemEnum::ForeignTypeItem,
-        TypedefItem(t, _) => ItemEnum::TypedefItem(t.into()),
-        OpaqueTyItem(t) => ItemEnum::OpaqueTyItem(t.into()),
-        ConstantItem(c) => ItemEnum::ConstantItem(c.into()),
-        MacroItem(m) => ItemEnum::MacroItem(m.source),
-        ProcMacroItem(m) => ItemEnum::ProcMacroItem(m.into()),
-        AssocConstItem(t, s) => ItemEnum::AssocConstItem { type_: t.into(), default: s },
-        AssocTypeItem(g, t) => ItemEnum::AssocTypeItem {
+        ModuleItem(m) => ItemEnum::Module(m.into()),
+        ImportItem(i) => ItemEnum::Import(i.into()),
+        StructItem(s) => ItemEnum::Struct(s.into()),
+        UnionItem(u) => ItemEnum::Union(u.into()),
+        StructFieldItem(f) => ItemEnum::StructField(f.into()),
+        EnumItem(e) => ItemEnum::Enum(e.into()),
+        VariantItem(v) => ItemEnum::Variant(v.into()),
+        FunctionItem(f) => ItemEnum::Function(f.into()),
+        ForeignFunctionItem(f) => ItemEnum::Function(f.into()),
+        TraitItem(t) => ItemEnum::Trait(t.into()),
+        TraitAliasItem(t) => ItemEnum::TraitAlias(t.into()),
+        MethodItem(m, _) => ItemEnum::Method(from_function_method(m, true)),
+        TyMethodItem(m) => ItemEnum::Method(from_function_method(m, false)),
+        ImplItem(i) => ItemEnum::Impl(i.into()),
+        StaticItem(s) => ItemEnum::Static(from_clean_static(s, tcx)),
+        ForeignStaticItem(s) => ItemEnum::Static(from_clean_static(s, tcx)),
+        ForeignTypeItem => ItemEnum::ForeignType,
+        TypedefItem(t, _) => ItemEnum::Typedef(t.into()),
+        OpaqueTyItem(t) => ItemEnum::OpaqueTy(t.into()),
+        ConstantItem(c) => ItemEnum::Constant(c.into()),
+        MacroItem(m) => ItemEnum::Macro(m.source),
+        ProcMacroItem(m) => ItemEnum::ProcMacro(m.into()),
+        AssocConstItem(t, s) => ItemEnum::AssocConst { type_: t.into(), default: s },
+        AssocTypeItem(g, t) => ItemEnum::AssocType {
             bounds: g.into_iter().map(Into::into).collect(),
             default: t.map(Into::into),
         },
         StrippedItem(inner) => from_clean_item_kind(*inner, tcx, name),
         PrimitiveItem(_) | KeywordItem(_) => {
             panic!("{:?} is not supported for JSON output", item)
         }
-        ExternCrateItem { ref src } => ItemEnum::ExternCrateItem {
+        ExternCrateItem { ref src } => ItemEnum::ExternCrate {
             name: name.as_ref().unwrap().to_string(),
             rename: src.map(|x| x.to_string()),
         },

src/librustdoc/json/mod.rs

@@ -108,8 +108,7 @@ impl JsonRenderer<'tcx> {
                                 .last()
                                 .map(Clone::clone),
                             visibility: types::Visibility::Public,
-                            kind: types::ItemKind::Trait,
-                            inner: types::ItemEnum::TraitItem(trait_item.clone().into()),
+                            inner: types::ItemEnum::Trait(trait_item.clone().into()),
                             source: None,
                             docs: Default::default(),
                             links: Default::default(),
@@ -158,11 +157,11 @@ impl<'tcx> FormatRenderer<'tcx> for JsonRenderer<'tcx> {
 
         let id = item.def_id;
         if let Some(mut new_item) = self.convert_item(item) {
-            if let types::ItemEnum::TraitItem(ref mut t) = new_item.inner {
+            if let types::ItemEnum::Trait(ref mut t) = new_item.inner {
                 t.implementors = self.get_trait_implementors(id)
-            } else if let types::ItemEnum::StructItem(ref mut s) = new_item.inner {
+            } else if let types::ItemEnum::Struct(ref mut s) = new_item.inner {
                 s.impls = self.get_impls(id)
-            } else if let types::ItemEnum::EnumItem(ref mut e) = new_item.inner {
+            } else if let types::ItemEnum::Enum(ref mut e) = new_item.inner {
                 e.impls = self.get_impls(id)
             }
             let removed = self.index.borrow_mut().insert(from_def_id(id), new_item.clone());

src/rustdoc-json-types/lib.rs

@@ -76,7 +76,7 @@ pub struct Item {
     /// Stringified versions of the attributes on this item (e.g. `"#[inline]"`)
     pub attrs: Vec<String>,
     pub deprecation: Option<Deprecation>,
-    pub kind: ItemKind,
+    #[serde(flatten)]
     pub inner: ItemEnum,
 }
 
@@ -185,48 +185,48 @@ pub enum ItemKind {
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-#[serde(untagged)]
+#[serde(tag = "kind", content = "inner", rename_all = "snake_case")]
 pub enum ItemEnum {
-    ModuleItem(Module),
-    ExternCrateItem {
+    Module(Module),
+    ExternCrate {
         name: String,
         rename: Option<String>,
     },
-    ImportItem(Import),
+    Import(Import),
 
-    UnionItem(Union),
-    StructItem(Struct),
-    StructFieldItem(Type),
-    EnumItem(Enum),
-    VariantItem(Variant),
+    Union(Union),
+    Struct(Struct),
+    StructField(Type),
+    Enum(Enum),
+    Variant(Variant),
 
-    FunctionItem(Function),
+    Function(Function),
 
-    TraitItem(Trait),
-    TraitAliasItem(TraitAlias),
-    MethodItem(Method),
-    ImplItem(Impl),
+    Trait(Trait),
+    TraitAlias(TraitAlias),
+    Method(Method),
+    Impl(Impl),
 
-    TypedefItem(Typedef),
-    OpaqueTyItem(OpaqueTy),
-    ConstantItem(Constant),
+    Typedef(Typedef),
+    OpaqueTy(OpaqueTy),
+    Constant(Constant),
 
-    StaticItem(Static),
+    Static(Static),
 
     /// `type`s from an extern block
-    ForeignTypeItem,
+    ForeignType,
 
     /// Declarative macro_rules! macro
-    MacroItem(String),
-    ProcMacroItem(ProcMacro),
+    Macro(String),
+    ProcMacro(ProcMacro),
 
-    AssocConstItem {
+    AssocConst {
         #[serde(rename = "type")]
         type_: Type,
         /// e.g. `const X: usize = 5;`
         default: Option<String>,
     },
-    AssocTypeItem {
+    AssocType {
         bounds: Vec<GenericBound>,
         /// e.g. `type X = usize;`
         default: Option<Type>,