diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 5ec79c586dcac..545f432def5a7 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1840,11 +1840,11 @@ impl Clean for rustc_hir::VariantData<'_> { impl Clean for ty::VariantDef { fn clean(&self, cx: &DocContext<'_>) -> Item { let kind = match self.ctor_kind { - CtorKind::Const => VariantKind::CLike, - CtorKind::Fn => VariantKind::Tuple( + CtorKind::Const => Variant::CLike, + CtorKind::Fn => Variant::Tuple( self.fields.iter().map(|f| cx.tcx.type_of(f.did).clean(cx)).collect(), ), - CtorKind::Fictive => VariantKind::Struct(VariantStruct { + CtorKind::Fictive => Variant::Struct(VariantStruct { struct_type: doctree::Plain, fields_stripped: false, fields: self @@ -1861,25 +1861,21 @@ impl Clean for ty::VariantDef { .collect(), }), }; - let what_rustc_thinks = Item::from_def_id_and_parts( - self.def_id, - Some(self.ident.name), - VariantItem(Variant { kind }), - cx, - ); + let what_rustc_thinks = + Item::from_def_id_and_parts(self.def_id, Some(self.ident.name), VariantItem(kind), cx); // don't show `pub` for fields, which are always public Item { visibility: Inherited, ..what_rustc_thinks } } } -impl Clean for hir::VariantData<'_> { - fn clean(&self, cx: &DocContext<'_>) -> VariantKind { +impl Clean for hir::VariantData<'_> { + fn clean(&self, cx: &DocContext<'_>) -> Variant { match self { - hir::VariantData::Struct(..) => VariantKind::Struct(self.clean(cx)), + hir::VariantData::Struct(..) => Variant::Struct(self.clean(cx)), hir::VariantData::Tuple(..) => { - VariantKind::Tuple(self.fields().iter().map(|x| x.ty.clean(cx)).collect()) + Variant::Tuple(self.fields().iter().map(|x| x.ty.clean(cx)).collect()) } - hir::VariantData::Unit(..) => VariantKind::CLike, + hir::VariantData::Unit(..) => Variant::CLike, } } } @@ -2048,7 +2044,7 @@ impl Clean> for (&hir::Item<'_>, Option) { impl Clean for hir::Variant<'_> { fn clean(&self, cx: &DocContext<'_>) -> Item { - let kind = VariantItem(Variant { kind: self.data.clean(cx) }); + let kind = VariantItem(self.data.clean(cx)); let what_rustc_thinks = Item::from_hir_id_and_parts(self.id, Some(self.ident.name), kind, cx); // don't show `pub` for variants, which are always public diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs index 1f63fe5b95708..666b11b5f806d 100644 --- a/src/librustdoc/clean/types.rs +++ b/src/librustdoc/clean/types.rs @@ -237,9 +237,7 @@ impl Item { match *self.kind { StructItem(ref _struct) => Some(_struct.fields_stripped), UnionItem(ref union) => Some(union.fields_stripped), - VariantItem(Variant { kind: VariantKind::Struct(ref vstruct) }) => { - Some(vstruct.fields_stripped) - } + VariantItem(Variant::Struct(ref vstruct)) => Some(vstruct.fields_stripped), _ => None, } } @@ -353,7 +351,7 @@ impl ItemKind { match self { StructItem(s) => s.fields.iter(), UnionItem(u) => u.fields.iter(), - VariantItem(Variant { kind: VariantKind::Struct(v) }) => v.fields.iter(), + VariantItem(Variant::Struct(v)) => v.fields.iter(), EnumItem(e) => e.variants.iter(), TraitItem(t) => t.items.iter(), ImplItem(i) => i.items.iter(), @@ -1719,12 +1717,7 @@ crate struct Enum { } #[derive(Clone, Debug)] -crate struct Variant { - crate kind: VariantKind, -} - -#[derive(Clone, Debug)] -crate enum VariantKind { +crate enum Variant { CLike, Tuple(Vec), Struct(VariantStruct), diff --git a/src/librustdoc/fold.rs b/src/librustdoc/fold.rs index 4d45c8866a793..b2773a29e2905 100644 --- a/src/librustdoc/fold.rs +++ b/src/librustdoc/fold.rs @@ -55,13 +55,13 @@ crate trait DocFolder: Sized { } VariantItem(i) => { let i2 = i.clone(); // this clone is small - match i.kind { - VariantKind::Struct(mut j) => { + match i { + Variant::Struct(mut j) => { let num_fields = j.fields.len(); j.fields = j.fields.into_iter().filter_map(|x| self.fold_item(x)).collect(); j.fields_stripped |= num_fields != j.fields.len() || j.fields.iter().any(|f| f.is_stripped()); - VariantItem(Variant { kind: VariantKind::Struct(j) }) + VariantItem(Variant::Struct(j)) } _ => VariantItem(i2), } diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs index 6a32be609911a..2db89e8a7ca68 100644 --- a/src/librustdoc/html/render/mod.rs +++ b/src/librustdoc/html/render/mod.rs @@ -3200,9 +3200,9 @@ fn item_enum(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, e: &clean::Enum write!(w, " "); let name = v.name.as_ref().unwrap(); match *v.kind { - clean::VariantItem(ref var) => match var.kind { - clean::VariantKind::CLike => write!(w, "{}", name), - clean::VariantKind::Tuple(ref tys) => { + clean::VariantItem(ref var) => match var { + clean::Variant::CLike => write!(w, "{}", name), + clean::Variant::Tuple(ref tys) => { write!(w, "{}(", name); for (i, ty) in tys.iter().enumerate() { if i > 0 { @@ -3212,7 +3212,7 @@ fn item_enum(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, e: &clean::Enum } write!(w, ")"); } - clean::VariantKind::Struct(ref s) => { + clean::Variant::Struct(ref s) => { render_struct(w, v, None, s.struct_type, &s.fields, " ", false, cx); } }, @@ -3249,25 +3249,22 @@ fn item_enum(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, e: &clean::Enum id = id, name = variant.name.as_ref().unwrap() ); - if let clean::VariantItem(ref var) = *variant.kind { - if let clean::VariantKind::Tuple(ref tys) = var.kind { - write!(w, "("); - for (i, ty) in tys.iter().enumerate() { - if i > 0 { - write!(w, ", "); - } - write!(w, "{}", ty.print()); + if let clean::VariantItem(clean::Variant::Tuple(ref tys)) = *variant.kind { + write!(w, "("); + for (i, ty) in tys.iter().enumerate() { + if i > 0 { + write!(w, ", "); } - write!(w, ")"); + write!(w, "{}", ty.print()); } + write!(w, ")"); } write!(w, ""); document(w, cx, variant, Some(it)); document_non_exhaustive(w, variant); - use crate::clean::{Variant, VariantKind}; - if let clean::VariantItem(Variant { kind: VariantKind::Struct(ref s) }) = *variant.kind - { + use crate::clean::Variant; + if let clean::VariantItem(Variant::Struct(ref s)) = *variant.kind { let variant_id = cx.derive_id(format!( "{}.{}.fields", ItemType::Variant, diff --git a/src/librustdoc/json/conversions.rs b/src/librustdoc/json/conversions.rs index 5dea64ef14587..7d05cb016b67c 100644 --- a/src/librustdoc/json/conversions.rs +++ b/src/librustdoc/json/conversions.rs @@ -482,8 +482,8 @@ impl From for Struct { impl From for Variant { fn from(variant: clean::Variant) -> Self { - use clean::VariantKind::*; - match variant.kind { + use clean::Variant::*; + match variant { CLike => Variant::Plain, Tuple(t) => Variant::Tuple(t.into_iter().map(Into::into).collect()), Struct(s) => Variant::Struct(ids(s.fields)), diff --git a/src/librustdoc/passes/stripper.rs b/src/librustdoc/passes/stripper.rs index a1924422f0e5e..162b70973b418 100644 --- a/src/librustdoc/passes/stripper.rs +++ b/src/librustdoc/passes/stripper.rs @@ -94,7 +94,7 @@ impl<'a> DocFolder for Stripper<'a> { // implementations of traits are always public. clean::ImplItem(ref imp) if imp.trait_.is_some() => true, // Struct variant fields have inherited visibility - clean::VariantItem(clean::Variant { kind: clean::VariantKind::Struct(..) }) => true, + clean::VariantItem(clean::Variant::Struct(..)) => true, _ => false, };