Skip to content

Commit ed30993

Browse files
GuillaumeGomezGuillaumeGomez
committed
Use the correct type for Enum variant tuples
1 parent 4a6547c commit ed30993

File tree

6 files changed

+62
-29
lines changed

6 files changed

+62
-29
lines changed

‎src/librustdoc/clean/mod.rs‎

Lines changed: 18 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1703,12 +1703,28 @@ impl Clean<VariantStruct> for rustc_hir::VariantData<'_> {
17031703
}
17041704
}
17051705

1706+
impl Clean<Vec<Item>> for hir::VariantData<'_> {
1707+
fn clean(&self, cx: &mut DocContext<'_>) -> Vec<Item> {
1708+
self.fields().iter().map(|x| x.clean(cx)).collect()
1709+
}
1710+
}
1711+
17061712
impl Clean<Item> for ty::VariantDef {
17071713
fn clean(&self, cx: &mut DocContext<'_>) -> Item {
17081714
let kind = match self.ctor_kind {
17091715
CtorKind::Const => Variant::CLike,
17101716
CtorKind::Fn => Variant::Tuple(
1711-
self.fields.iter().map(|f| cx.tcx.type_of(f.did).clean(cx)).collect(),
1717+
self.fields
1718+
.iter()
1719+
.map(|field| {
1720+
let name = Some(field.ident.name);
1721+
let kind = StructFieldItem(cx.tcx.type_of(field.did).clean(cx));
1722+
let what_rustc_thinks =
1723+
Item::from_def_id_and_parts(field.did, name, kind, cx);
1724+
// don't show `pub` for fields, which are always public
1725+
Item { visibility: Visibility::Inherited, ..what_rustc_thinks }
1726+
})
1727+
.collect(),
17121728
),
17131729
CtorKind::Fictive => Variant::Struct(VariantStruct {
17141730
struct_type: CtorKind::Fictive,
@@ -1738,13 +1754,7 @@ impl Clean<Variant> for hir::VariantData<'_> {
17381754
fn clean(&self, cx: &mut DocContext<'_>) -> Variant {
17391755
match self {
17401756
hir::VariantData::Struct(..) => Variant::Struct(self.clean(cx)),
1741-
// Important note here: `Variant::Tuple` is used on tuple structs which are not in an
1742-
// enum (so where converting from `ty::VariantDef`). In case we are in an enum, the kind
1743-
// is provided by the `Variant` wrapper directly, and since we need the fields' name
1744-
// (even for a tuple struct variant!), it's simpler to just store it as a
1745-
// `Variant::Struct` instead of a `Variant::Tuple` (otherwise it would force us to make
1746-
// a lot of changes when rendering them to generate the name as well).
1747-
hir::VariantData::Tuple(..) => Variant::Struct(self.clean(cx)),
1757+
hir::VariantData::Tuple(..) => Variant::Tuple(self.clean(cx)),
17481758
hir::VariantData::Unit(..) => Variant::CLike,
17491759
}
17501760
}

‎src/librustdoc/clean/types.rs‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -715,6 +715,7 @@ impl ItemKind {
715715
StructItem(s) => s.fields.iter(),
716716
UnionItem(u) => u.fields.iter(),
717717
VariantItem(Variant::Struct(v)) => v.fields.iter(),
718+
VariantItem(Variant::Tuple(v)) => v.iter(),
718719
EnumItem(e) => e.variants.iter(),
719720
TraitItem(t) => t.items.iter(),
720721
ImplItem(i) => i.items.iter(),
@@ -1937,7 +1938,7 @@ crate struct Enum {
19371938
#[derive(Clone, Debug)]
19381939
crate enum Variant {
19391940
CLike,
1940-
Tuple(Vec<Type>),
1941+
Tuple(Vec<Item>),
19411942
Struct(VariantStruct),
19421943
}
19431944

‎src/librustdoc/fold.rs‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -56,6 +56,10 @@ crate trait DocFolder: Sized {
5656
|| j.fields.iter().any(|f| f.is_stripped());
5757
VariantItem(Variant::Struct(j))
5858
}
59+
Variant::Tuple(fields) => {
60+
let fields = fields.into_iter().filter_map(|x| self.fold_item(x)).collect();
61+
VariantItem(Variant::Tuple(fields))
62+
}
5963
_ => VariantItem(i2),
6064
}
6165
}

‎src/librustdoc/html/render/print_item.rs‎

Lines changed: 24 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -937,6 +937,19 @@ fn item_union(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, s: &clean::Uni
937937
document_type_layout(w, cx, def_id);
938938
}
939939

940+
fn print_tuple_struct_fields(w: &mut Buffer, cx: &Context<'_>, s: &[clean::Item]) {
941+
for (i, ty) in s
942+
.iter()
943+
.map(|f| if let clean::StructFieldItem(ref ty) = *f.kind { ty } else { unreachable!() })
944+
.enumerate()
945+
{
946+
if i > 0 {
947+
w.write_str(",&nbsp;");
948+
}
949+
write!(w, "{}", ty.print(cx));
950+
}
951+
}
952+
940953
fn item_enum(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, e: &clean::Enum) {
941954
wrap_into_docblock(w, |w| {
942955
wrap_item(w, "enum", |w| {
@@ -964,14 +977,9 @@ fn item_enum(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, e: &clean::Enum
964977
match *v.kind {
965978
clean::VariantItem(ref var) => match var {
966979
clean::Variant::CLike => write!(w, "{}", name),
967-
clean::Variant::Tuple(ref tys) => {
980+
clean::Variant::Tuple(ref s) => {
968981
write!(w, "{}(", name);
969-
for (i, ty) in tys.iter().enumerate() {
970-
if i > 0 {
971-
w.write_str(",&nbsp;")
972-
}
973-
write!(w, "{}", ty.print(cx));
974-
}
982+
print_tuple_struct_fields(w, cx, s);
975983
w.write_str(")");
976984
}
977985
clean::Variant::Struct(ref s) => {
@@ -1024,14 +1032,9 @@ fn item_enum(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, e: &clean::Enum
10241032
id = id,
10251033
name = variant.name.as_ref().unwrap()
10261034
);
1027-
if let clean::VariantItem(clean::Variant::Tuple(ref tys)) = *variant.kind {
1035+
if let clean::VariantItem(clean::Variant::Tuple(ref s)) = *variant.kind {
10281036
w.write_str("(");
1029-
for (i, ty) in tys.iter().enumerate() {
1030-
if i > 0 {
1031-
w.write_str(",&nbsp;");
1032-
}
1033-
write!(w, "{}", ty.print(cx));
1034-
}
1037+
print_tuple_struct_fields(w, cx, s);
10351038
w.write_str(")");
10361039
}
10371040
w.write_str("</code>");
@@ -1041,7 +1044,11 @@ fn item_enum(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, e: &clean::Enum
10411044
document_non_exhaustive(w, variant);
10421045

10431046
use crate::clean::Variant;
1044-
if let clean::VariantItem(Variant::Struct(ref s)) = *variant.kind {
1047+
if let Some((extra, fields)) = match *variant.kind {
1048+
clean::VariantItem(Variant::Struct(ref s)) => Some(("", &s.fields)),
1049+
clean::VariantItem(Variant::Tuple(ref fields)) => Some(("Tuple ", fields)),
1050+
_ => None,
1051+
} {
10451052
let variant_id = cx.derive_id(format!(
10461053
"{}.{}.fields",
10471054
ItemType::Variant,
@@ -1051,10 +1058,10 @@ fn item_enum(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, e: &clean::Enum
10511058
write!(
10521059
w,
10531060
"<h3>{extra}Fields of <b>{name}</b></h3><div>",
1054-
extra = if s.struct_type == CtorKind::Fn { "Tuple " } else { "" },
1061+
extra = extra,
10551062
name = variant.name.as_ref().unwrap(),
10561063
);
1057-
for field in &s.fields {
1064+
for field in fields {
10581065
use crate::clean::StructFieldItem;
10591066
if let StructFieldItem(ref ty) = *field.kind {
10601067
let id = cx.derive_id(format!(

‎src/librustdoc/json/conversions.rs‎

Lines changed: 12 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -569,7 +569,18 @@ impl FromWithTcx<clean::Variant> for Variant {
569569
use clean::Variant::*;
570570
match variant {
571571
CLike => Variant::Plain,
572-
Tuple(t) => Variant::Tuple(t.into_iter().map(|x| x.into_tcx(tcx)).collect()),
572+
Tuple(fields) => Variant::Tuple(
573+
fields
574+
.into_iter()
575+
.map(|f| {
576+
if let clean::StructFieldItem(ty) = *f.kind {
577+
ty.into_tcx(tcx)
578+
} else {
579+
unreachable!()
580+
}
581+
})
582+
.collect(),
583+
),
573584
Struct(s) => Variant::Struct(ids(s.fields)),
574585
}
575586
}

‎src/librustdoc/passes/stripper.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -93,8 +93,8 @@ impl<'a> DocFolder for Stripper<'a> {
9393

9494
// implementations of traits are always public.
9595
clean::ImplItem(ref imp) if imp.trait_.is_some() => true,
96-
// Struct variant fields have inherited visibility
97-
clean::VariantItem(clean::Variant::Struct(..)) => true,
96+
// Variant fields have inherited visibility
97+
clean::VariantItem(clean::Variant::Struct(..) | clean::Variant::Tuple(..)) => true,
9898
_ => false,
9999
};
100100

0 commit comments

Comments
 (0)