From 8098f5faa880df18b0d7c83fdf5df8211a9e8dee Mon Sep 17 00:00:00 2001 From: Guillaume Gomez Date: Sun, 24 Jul 2022 14:58:10 +0200 Subject: [PATCH 1/2] Remove Clean trait implementation for FieldDef --- src/librustdoc/clean/inline.rs | 8 +++--- src/librustdoc/clean/mod.rs | 47 +++++++++++++++++----------------- 2 files changed, 28 insertions(+), 27 deletions(-) diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs index 7a4ec889ac757..4b91f7ba096cb 100644 --- a/src/librustdoc/clean/inline.rs +++ b/src/librustdoc/clean/inline.rs @@ -16,8 +16,8 @@ use rustc_span::hygiene::MacroKind; use rustc_span::symbol::{kw, sym, Symbol}; use crate::clean::{ - self, clean_fn_decl_from_did_and_sig, clean_middle_ty, clean_ty, clean_ty_generics, utils, - Attributes, AttributesExt, Clean, ImplKind, ItemId, Type, Visibility, + self, clean_fn_decl_from_did_and_sig, clean_middle_field, clean_middle_ty, clean_ty, + clean_ty_generics, utils, Attributes, AttributesExt, Clean, ImplKind, ItemId, Type, Visibility, }; use crate::core::DocContext; use crate::formats::item_type::ItemType; @@ -246,7 +246,7 @@ fn build_struct(cx: &mut DocContext<'_>, did: DefId) -> clean::Struct { clean::Struct { struct_type: variant.ctor_kind, generics: clean_ty_generics(cx, cx.tcx.generics_of(did), predicates), - fields: variant.fields.iter().map(|x| x.clean(cx)).collect(), + fields: variant.fields.iter().map(|x| clean_middle_field(x, cx)).collect(), } } @@ -255,7 +255,7 @@ fn build_union(cx: &mut DocContext<'_>, did: DefId) -> clean::Union { let variant = cx.tcx.adt_def(did).non_enum_variant(); let generics = clean_ty_generics(cx, cx.tcx.generics_of(did), predicates); - let fields = variant.fields.iter().map(|x| x.clean(cx)).collect(); + let fields = variant.fields.iter().map(|x| clean_middle_field(x, cx)).collect(); clean::Union { generics, fields } } diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 6160783f652f1..4c790e809c4a9 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1774,25 +1774,26 @@ impl<'tcx> Clean<'tcx, Constant> for ty::Const<'tcx> { } } -impl<'tcx> Clean<'tcx, Item> for hir::FieldDef<'tcx> { - fn clean(&self, cx: &mut DocContext<'tcx>) -> Item { - let def_id = cx.tcx.hir().local_def_id(self.hir_id).to_def_id(); - clean_field(def_id, self.ident.name, clean_ty(self.ty, cx), cx) - } +pub(crate) fn clean_field<'tcx>(field: &hir::FieldDef<'tcx>, cx: &mut DocContext<'tcx>) -> Item { + let def_id = cx.tcx.hir().local_def_id(field.hir_id).to_def_id(); + clean_field_with_def_id(def_id, field.ident.name, clean_ty(field.ty, cx), cx) } -impl<'tcx> Clean<'tcx, Item> for ty::FieldDef { - fn clean(&self, cx: &mut DocContext<'tcx>) -> Item { - clean_field( - self.did, - self.name, - clean_middle_ty(cx.tcx.type_of(self.did), cx, Some(self.did)), - cx, - ) - } +pub(crate) fn clean_middle_field<'tcx>(field: &ty::FieldDef, cx: &mut DocContext<'tcx>) -> Item { + clean_field_with_def_id( + field.did, + field.name, + clean_middle_ty(cx.tcx.type_of(field.did), cx, Some(field.did)), + cx, + ) } -fn clean_field(def_id: DefId, name: Symbol, ty: Type, cx: &mut DocContext<'_>) -> Item { +pub(crate) fn clean_field_with_def_id( + def_id: DefId, + name: Symbol, + ty: Type, + cx: &mut DocContext<'_>, +) -> Item { let what_rustc_thinks = Item::from_def_id_and_parts(def_id, Some(name), StructFieldItem(ty), cx); if is_field_vis_inherited(cx.tcx, def_id) { @@ -1830,14 +1831,14 @@ impl<'tcx> Clean<'tcx, VariantStruct> for rustc_hir::VariantData<'tcx> { fn clean(&self, cx: &mut DocContext<'tcx>) -> VariantStruct { VariantStruct { struct_type: CtorKind::from_hir(self), - fields: self.fields().iter().map(|x| x.clean(cx)).collect(), + fields: self.fields().iter().map(|x| clean_field(x, cx)).collect(), } } } impl<'tcx> Clean<'tcx, Vec> for hir::VariantData<'tcx> { fn clean(&self, cx: &mut DocContext<'tcx>) -> Vec { - self.fields().iter().map(|x| x.clean(cx)).collect() + self.fields().iter().map(|x| clean_field(x, cx)).collect() } } @@ -1845,12 +1846,12 @@ impl<'tcx> Clean<'tcx, Item> for ty::VariantDef { fn clean(&self, cx: &mut DocContext<'tcx>) -> Item { let kind = match self.ctor_kind { CtorKind::Const => Variant::CLike, - CtorKind::Fn => { - Variant::Tuple(self.fields.iter().map(|field| field.clean(cx)).collect()) - } + CtorKind::Fn => Variant::Tuple( + self.fields.iter().map(|field| clean_middle_field(field, cx)).collect(), + ), CtorKind::Fictive => Variant::Struct(VariantStruct { struct_type: CtorKind::Fictive, - fields: self.fields.iter().map(|field| field.clean(cx)).collect(), + fields: self.fields.iter().map(|field| clean_middle_field(field, cx)).collect(), }), }; let what_rustc_thinks = @@ -1970,12 +1971,12 @@ fn clean_maybe_renamed_item<'tcx>( }), ItemKind::Union(ref variant_data, generics) => UnionItem(Union { generics: generics.clean(cx), - fields: variant_data.fields().iter().map(|x| x.clean(cx)).collect(), + fields: variant_data.fields().iter().map(|x| clean_field(x, cx)).collect(), }), ItemKind::Struct(ref variant_data, generics) => StructItem(Struct { struct_type: CtorKind::from_hir(variant_data), generics: generics.clean(cx), - fields: variant_data.fields().iter().map(|x| x.clean(cx)).collect(), + fields: variant_data.fields().iter().map(|x| clean_field(x, cx)).collect(), }), ItemKind::Impl(impl_) => return clean_impl(impl_, item.hir_id(), cx), // proc macros can have a name set by attributes From e55b0206f3e889bb90b734828e9c90dfdb426a92 Mon Sep 17 00:00:00 2001 From: Guillaume Gomez Date: Sun, 24 Jul 2022 15:08:24 +0200 Subject: [PATCH 2/2] Remove Clean trait implementation for Constant --- src/librustdoc/clean/mod.rs | 45 ++++++++++++++++++----------------- src/librustdoc/clean/utils.rs | 8 +++---- 2 files changed, 27 insertions(+), 26 deletions(-) diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 4c790e809c4a9..c9ef4748a4845 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -237,13 +237,22 @@ impl<'tcx> Clean<'tcx, Lifetime> for hir::Lifetime { } } -impl<'tcx> Clean<'tcx, Constant> for hir::ConstArg { - fn clean(&self, cx: &mut DocContext<'tcx>) -> Constant { - let def_id = cx.tcx.hir().body_owner_def_id(self.value.body).to_def_id(); - Constant { - type_: clean_middle_ty(cx.tcx.type_of(def_id), cx, Some(def_id)), - kind: ConstantKind::Anonymous { body: self.value.body }, - } +pub(crate) fn clean_const<'tcx>(constant: &hir::ConstArg, cx: &mut DocContext<'tcx>) -> Constant { + let def_id = cx.tcx.hir().body_owner_def_id(constant.value.body).to_def_id(); + Constant { + type_: clean_middle_ty(cx.tcx.type_of(def_id), cx, Some(def_id)), + kind: ConstantKind::Anonymous { body: constant.value.body }, + } +} + +pub(crate) fn clean_middle_const<'tcx>( + constant: ty::Const<'tcx>, + cx: &mut DocContext<'tcx>, +) -> Constant { + // FIXME: instead of storing the stringified expression, store `self` directly instead. + Constant { + type_: clean_middle_ty(constant.ty(), cx, None), + kind: ConstantKind::TyConst { expr: constant.to_string() }, } } @@ -392,7 +401,7 @@ impl<'tcx> Clean<'tcx, Term> for ty::Term<'tcx> { fn clean(&self, cx: &mut DocContext<'tcx>) -> Term { match self { ty::Term::Ty(ty) => Term::Type(clean_middle_ty(*ty, cx, None)), - ty::Term::Const(c) => Term::Constant(c.clean(cx)), + ty::Term::Const(c) => Term::Constant(clean_middle_const(*c, cx)), } } } @@ -403,7 +412,7 @@ impl<'tcx> Clean<'tcx, Term> for hir::Term<'tcx> { hir::Term::Ty(ty) => Term::Type(clean_ty(ty, cx)), hir::Term::Const(c) => { let def_id = cx.tcx.hir().local_def_id(c.hir_id); - Term::Constant(ty::Const::from_anon_const(cx.tcx, def_id).clean(cx)) + Term::Constant(clean_middle_const(ty::Const::from_anon_const(cx.tcx, def_id), cx)) } } } @@ -1468,8 +1477,10 @@ fn maybe_expand_private_type_alias<'tcx>( _ => None, }); if let Some(ct) = const_ { - substs - .insert(const_param_def_id.to_def_id(), SubstParam::Constant(ct.clean(cx))); + substs.insert( + const_param_def_id.to_def_id(), + SubstParam::Constant(clean_const(ct, cx)), + ); } // FIXME(const_generics_defaults) indices.consts += 1; @@ -1764,16 +1775,6 @@ pub(crate) fn clean_middle_ty<'tcx>( } } -impl<'tcx> Clean<'tcx, Constant> for ty::Const<'tcx> { - fn clean(&self, cx: &mut DocContext<'tcx>) -> Constant { - // FIXME: instead of storing the stringified expression, store `self` directly instead. - Constant { - type_: clean_middle_ty(self.ty(), cx, None), - kind: ConstantKind::TyConst { expr: self.to_string() }, - } - } -} - pub(crate) fn clean_field<'tcx>(field: &hir::FieldDef<'tcx>, cx: &mut DocContext<'tcx>) -> Item { let def_id = cx.tcx.hir().local_def_id(field.hir_id).to_def_id(); clean_field_with_def_id(def_id, field.ident.name, clean_ty(field.ty, cx), cx) @@ -1895,7 +1896,7 @@ impl<'tcx> Clean<'tcx, GenericArgs> for hir::GenericArgs<'tcx> { } hir::GenericArg::Lifetime(_) => GenericArg::Lifetime(Lifetime::elided()), hir::GenericArg::Type(ty) => GenericArg::Type(clean_ty(ty, cx)), - hir::GenericArg::Const(ct) => GenericArg::Const(Box::new(ct.clean(cx))), + hir::GenericArg::Const(ct) => GenericArg::Const(Box::new(clean_const(ct, cx))), hir::GenericArg::Infer(_inf) => GenericArg::Infer, }) .collect::>() diff --git a/src/librustdoc/clean/utils.rs b/src/librustdoc/clean/utils.rs index 00d62b3748455..27ecea5cc40bd 100644 --- a/src/librustdoc/clean/utils.rs +++ b/src/librustdoc/clean/utils.rs @@ -2,9 +2,9 @@ use crate::clean::auto_trait::AutoTraitFinder; use crate::clean::blanket_impl::BlanketImplFinder; use crate::clean::render_macro_matchers::render_macro_matcher; use crate::clean::{ - clean_middle_ty, inline, Clean, Crate, ExternalCrate, Generic, GenericArg, GenericArgs, - ImportSource, Item, ItemKind, Lifetime, Path, PathSegment, Primitive, PrimitiveType, Type, - TypeBinding, Visibility, + clean_middle_const, clean_middle_ty, inline, Clean, Crate, ExternalCrate, Generic, GenericArg, + GenericArgs, ImportSource, Item, ItemKind, Lifetime, Path, PathSegment, Primitive, + PrimitiveType, Type, TypeBinding, Visibility, }; use crate::core::DocContext; use crate::formats::item_type::ItemType; @@ -93,7 +93,7 @@ pub(crate) fn substs_to_args<'tcx>( None } GenericArgKind::Type(ty) => Some(GenericArg::Type(clean_middle_ty(ty, cx, None))), - GenericArgKind::Const(ct) => Some(GenericArg::Const(Box::new(ct.clean(cx)))), + GenericArgKind::Const(ct) => Some(GenericArg::Const(Box::new(clean_middle_const(ct, cx)))), })); ret_val }