Skip to content

Commit f4f5dd5

Browse files
m-ou-sem-ou-se
authored
Rollup merge of rust-lang#88391 - GuillaumeGomez:fix-json-enum-variant, r=camelid,notriddle
Fix json tuple struct enum variant Fixes rust-lang#87887. cc `@dsherret` `@camelid` r? `@notriddle`
2 parents 175c8cb + a521388 commit f4f5dd5

File tree

8 files changed

+79
-29
lines changed

8 files changed

+79
-29
lines changed

Diff for: ‎src/librustdoc/clean/mod.rs

+18-8
Original file line numberDiff line numberDiff line change
@@ -1702,12 +1702,28 @@ impl Clean<VariantStruct> for rustc_hir::VariantData<'_> {
17021702
}
17031703
}
17041704

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

Diff for: ‎src/librustdoc/clean/types.rs

+2-1
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

Diff for: ‎src/librustdoc/fold.rs

+4
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
}

Diff for: ‎src/librustdoc/html/render/print_item.rs

+24-17
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!(

Diff for: ‎src/librustdoc/json/conversions.rs

+12-1
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
}

Diff for: ‎src/librustdoc/passes/stripper.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -94,8 +94,8 @@ impl<'a> DocFolder for Stripper<'a> {
9494

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

Diff for: ‎src/test/rustdoc-json/enums/variant_struct.rs

+11
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
// @has variant_struct.json "$.index[*][?(@.name=='EnumStruct')].visibility" \"public\"
2+
// @has - "$.index[*][?(@.name=='EnumStruct')].kind" \"enum\"
3+
pub enum EnumStruct {
4+
// @has - "$.index[*][?(@.name=='VariantS')].inner.variant_kind" \"struct\"
5+
// @has - "$.index[*][?(@.name=='x')]"
6+
// @has - "$.index[*][?(@.name=='y')]"
7+
VariantS {
8+
x: u32,
9+
y: String,
10+
},
11+
}

Diff for: ‎src/test/rustdoc-json/enums/variant_tuple_struct.rs

+6
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,6 @@
1+
// @has variant_tuple_struct.json "$.index[*][?(@.name=='EnumTupleStruct')].visibility" \"public\"
2+
// @has - "$.index[*][?(@.name=='EnumTupleStruct')].kind" \"enum\"
3+
pub enum EnumTupleStruct {
4+
// @has - "$.index[*][?(@.name=='VariantA')].inner.variant_kind" \"tuple\"
5+
VariantA(u32, String),
6+
}

0 commit comments

Comments
 (0)