From d4684182096326ccc57ea70bdb080c95607ff238 Mon Sep 17 00:00:00 2001 From: Muhammad Falak R Wani Date: Mon, 1 Nov 2021 12:02:01 +0530 Subject: [PATCH 1/2] rustdoc: use Type::def_id() instead of Type::def_id_no_primitives() Signed-off-by: Muhammad Falak R Wani --- src/librustdoc/formats/cache.rs | 2 +- src/librustdoc/html/render/cache.rs | 48 +++++++++++--------- src/librustdoc/html/render/mod.rs | 2 +- src/librustdoc/passes/collect_trait_impls.rs | 7 +-- 4 files changed, 33 insertions(+), 26 deletions(-) diff --git a/src/librustdoc/formats/cache.rs b/src/librustdoc/formats/cache.rs index 6b9c9a9669b1a..1e951a89023f6 100644 --- a/src/librustdoc/formats/cache.rs +++ b/src/librustdoc/formats/cache.rs @@ -303,7 +303,7 @@ impl<'a, 'tcx> DocFolder for CacheBuilder<'a, 'tcx> { desc, parent, parent_idx: None, - search_type: get_index_search_type(&item, self.tcx), + search_type: get_index_search_type(&item, self.tcx, self.cache), aliases: item.attrs.get_doc_aliases(), }); } diff --git a/src/librustdoc/html/render/cache.rs b/src/librustdoc/html/render/cache.rs index ff1bd5e7ff289..a4a43cba4e69c 100644 --- a/src/librustdoc/html/render/cache.rs +++ b/src/librustdoc/html/render/cache.rs @@ -43,7 +43,7 @@ crate fn build_index<'tcx>(krate: &clean::Crate, cache: &mut Cache, tcx: TyCtxt< desc, parent: Some(did), parent_idx: None, - search_type: get_index_search_type(item, tcx), + search_type: get_index_search_type(item, tcx, cache), aliases: item.attrs.get_doc_aliases(), }); } @@ -191,11 +191,12 @@ crate fn build_index<'tcx>(krate: &clean::Crate, cache: &mut Cache, tcx: TyCtxt< crate fn get_index_search_type<'tcx>( item: &clean::Item, tcx: TyCtxt<'tcx>, + cache: &Cache, ) -> Option { let (mut inputs, mut output) = match *item.kind { - clean::FunctionItem(ref f) => get_all_types(&f.generics, &f.decl, tcx), - clean::MethodItem(ref m, _) => get_all_types(&m.generics, &m.decl, tcx), - clean::TyMethodItem(ref m) => get_all_types(&m.generics, &m.decl, tcx), + clean::FunctionItem(ref f) => get_all_types(&f.generics, &f.decl, tcx, cache), + clean::MethodItem(ref m, _) => get_all_types(&m.generics, &m.decl, tcx, cache), + clean::TyMethodItem(ref m) => get_all_types(&m.generics, &m.decl, tcx, cache), _ => return None, }; @@ -249,12 +250,14 @@ crate fn get_real_types<'tcx>( tcx: TyCtxt<'tcx>, recurse: usize, res: &mut Vec, + cache: &Cache, ) { fn insert_ty( res: &mut Vec, tcx: TyCtxt<'_>, ty: Type, mut generics: Vec, + cache: &Cache, ) { let is_full_generic = ty.is_full_generic(); @@ -306,7 +309,7 @@ crate fn get_real_types<'tcx>( // We remove the name of the full generic because we have no use for it. index_ty.name = Some(String::new()); res.push(TypeWithKind::from((index_ty, ItemType::Generic))); - } else if let Some(kind) = ty.def_id_no_primitives().map(|did| tcx.def_kind(did).into()) { + } else if let Some(kind) = ty.def_id(cache).map(|did| tcx.def_kind(did).into()) { res.push(TypeWithKind::from((index_ty, kind))); } else if ty.is_primitive() { // This is a primitive, let's store it as such. @@ -321,9 +324,7 @@ crate fn get_real_types<'tcx>( if let Type::Generic(arg_s) = *arg { if let Some(where_pred) = generics.where_predicates.iter().find(|g| match g { - WherePredicate::BoundPredicate { ty, .. } => { - ty.def_id_no_primitives() == arg.def_id_no_primitives() - } + WherePredicate::BoundPredicate { ty, .. } => ty.def_id(cache) == arg.def_id(cache), _ => false, }) { let mut ty_generics = Vec::new(); @@ -335,31 +336,38 @@ crate fn get_real_types<'tcx>( continue; } if let Some(ty) = x.get_type() { - get_real_types(generics, &ty, tcx, recurse + 1, &mut ty_generics); + get_real_types( + generics, + &ty, + tcx, + recurse + 1, + &mut ty_generics, + cache, + ); } } } } - insert_ty(res, tcx, arg.clone(), ty_generics); + insert_ty(res, tcx, arg.clone(), ty_generics, cache); } if let Some(bound) = generics.params.iter().find(|g| g.is_type() && g.name == arg_s) { let mut ty_generics = Vec::new(); for bound in bound.get_bounds().unwrap_or(&[]) { if let Some(path) = bound.get_trait_path() { let ty = Type::ResolvedPath { did: path.def_id(), path }; - get_real_types(generics, &ty, tcx, recurse + 1, &mut ty_generics); + get_real_types(generics, &ty, tcx, recurse + 1, &mut ty_generics, cache); } } - insert_ty(res, tcx, arg.clone(), ty_generics); + insert_ty(res, tcx, arg.clone(), ty_generics, cache); } } else { let mut ty_generics = Vec::new(); if let Some(arg_generics) = arg.generics() { for gen in arg_generics.iter() { - get_real_types(generics, gen, tcx, recurse + 1, &mut ty_generics); + get_real_types(generics, gen, tcx, recurse + 1, &mut ty_generics, cache); } } - insert_ty(res, tcx, arg.clone(), ty_generics); + insert_ty(res, tcx, arg.clone(), ty_generics, cache); } } @@ -371,6 +379,7 @@ crate fn get_all_types<'tcx>( generics: &Generics, decl: &FnDecl, tcx: TyCtxt<'tcx>, + cache: &Cache, ) -> (Vec, Vec) { let mut all_types = Vec::new(); for arg in decl.inputs.values.iter() { @@ -380,14 +389,13 @@ crate fn get_all_types<'tcx>( // FIXME: performance wise, it'd be much better to move `args` declaration outside of the // loop and replace this line with `args.clear()`. let mut args = Vec::new(); - get_real_types(generics, &arg.type_, tcx, 0, &mut args); + get_real_types(generics, &arg.type_, tcx, 0, &mut args, cache); if !args.is_empty() { // FIXME: once back to performance improvements, replace this line with: // `all_types.extend(args.drain(..));`. all_types.extend(args); } else { - if let Some(kind) = arg.type_.def_id_no_primitives().map(|did| tcx.def_kind(did).into()) - { + if let Some(kind) = arg.type_.def_id(cache).map(|did| tcx.def_kind(did).into()) { all_types.push(TypeWithKind::from((get_index_type(&arg.type_, vec![]), kind))); } } @@ -396,11 +404,9 @@ crate fn get_all_types<'tcx>( let mut ret_types = Vec::new(); match decl.output { FnRetTy::Return(ref return_type) => { - get_real_types(generics, return_type, tcx, 0, &mut ret_types); + get_real_types(generics, return_type, tcx, 0, &mut ret_types, cache); if ret_types.is_empty() { - if let Some(kind) = - return_type.def_id_no_primitives().map(|did| tcx.def_kind(did).into()) - { + if let Some(kind) = return_type.def_id(cache).map(|did| tcx.def_kind(did).into()) { ret_types.push(TypeWithKind::from((get_index_type(return_type, vec![]), kind))); } } diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs index 25fef114d95fd..fdc552872ca73 100644 --- a/src/librustdoc/html/render/mod.rs +++ b/src/librustdoc/html/render/mod.rs @@ -2166,7 +2166,7 @@ fn sidebar_deref_methods( } // Recurse into any further impls that might exist for `target` - if let Some(target_did) = target.def_id_no_primitives() { + if let Some(target_did) = target.def_id(c) { if let Some(target_impls) = c.impls.get(&target_did) { if let Some(target_deref_impl) = target_impls.iter().find(|i| { i.inner_impl() diff --git a/src/librustdoc/passes/collect_trait_impls.rs b/src/librustdoc/passes/collect_trait_impls.rs index 77513b05ff2f9..2aaf1dabd8696 100644 --- a/src/librustdoc/passes/collect_trait_impls.rs +++ b/src/librustdoc/passes/collect_trait_impls.rs @@ -57,6 +57,7 @@ crate fn collect_trait_impls(mut krate: Crate, cx: &mut DocContext<'_>) -> Crate // Follow all `Deref` targets of included items and recursively add them as valid fn add_deref_target( + cx: &DocContext<'_>, map: &FxHashMap, cleaner: &mut BadImplStripper, type_did: DefId, @@ -65,14 +66,14 @@ crate fn collect_trait_impls(mut krate: Crate, cx: &mut DocContext<'_>) -> Crate debug!("add_deref_target: type {:?}, target {:?}", type_did, target); if let Some(target_prim) = target.primitive_type() { cleaner.prims.insert(target_prim); - } else if let Some(target_did) = target.def_id_no_primitives() { + } else if let Some(target_did) = target.def_id(&cx.cache) { // `impl Deref for S` if target_did == type_did { // Avoid infinite cycles return; } cleaner.items.insert(target_did.into()); - add_deref_target(map, cleaner, target_did); + add_deref_target(cx, map, cleaner, target_did); } } } @@ -102,7 +103,7 @@ crate fn collect_trait_impls(mut krate: Crate, cx: &mut DocContext<'_>) -> Crate // `Deref` target type and the impl for type positions, this map of types is keyed by // `DefId` and for convenience uses a special cleaner that accepts `DefId`s directly. if cleaner.keep_impl_with_def_id(for_did.into()) { - add_deref_target(&type_did_to_deref_target, &mut cleaner, for_did); + add_deref_target(cx, &type_did_to_deref_target, &mut cleaner, for_did); } } } From 5cfc7ce3372852b76dce6e6354faa3e7f0bf8598 Mon Sep 17 00:00:00 2001 From: Muhammad Falak R Wani Date: Thu, 11 Nov 2021 12:00:02 +0530 Subject: [PATCH 2/2] librustdoc: revert use of def_id for one of the edge case Signed-off-by: Muhammad Falak R Wani --- src/librustdoc/html/render/cache.rs | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/src/librustdoc/html/render/cache.rs b/src/librustdoc/html/render/cache.rs index a4a43cba4e69c..1dda80ff38c58 100644 --- a/src/librustdoc/html/render/cache.rs +++ b/src/librustdoc/html/render/cache.rs @@ -257,7 +257,7 @@ crate fn get_real_types<'tcx>( tcx: TyCtxt<'_>, ty: Type, mut generics: Vec, - cache: &Cache, + _cache: &Cache, ) { let is_full_generic = ty.is_full_generic(); @@ -309,7 +309,7 @@ crate fn get_real_types<'tcx>( // We remove the name of the full generic because we have no use for it. index_ty.name = Some(String::new()); res.push(TypeWithKind::from((index_ty, ItemType::Generic))); - } else if let Some(kind) = ty.def_id(cache).map(|did| tcx.def_kind(did).into()) { + } else if let Some(kind) = ty.def_id_no_primitives().map(|did| tcx.def_kind(did).into()) { res.push(TypeWithKind::from((index_ty, kind))); } else if ty.is_primitive() { // This is a primitive, let's store it as such. @@ -324,7 +324,9 @@ crate fn get_real_types<'tcx>( if let Type::Generic(arg_s) = *arg { if let Some(where_pred) = generics.where_predicates.iter().find(|g| match g { - WherePredicate::BoundPredicate { ty, .. } => ty.def_id(cache) == arg.def_id(cache), + WherePredicate::BoundPredicate { ty, .. } => { + ty.def_id_no_primitives() == arg.def_id_no_primitives() + } _ => false, }) { let mut ty_generics = Vec::new(); @@ -395,7 +397,8 @@ crate fn get_all_types<'tcx>( // `all_types.extend(args.drain(..));`. all_types.extend(args); } else { - if let Some(kind) = arg.type_.def_id(cache).map(|did| tcx.def_kind(did).into()) { + if let Some(kind) = arg.type_.def_id_no_primitives().map(|did| tcx.def_kind(did).into()) + { all_types.push(TypeWithKind::from((get_index_type(&arg.type_, vec![]), kind))); } } @@ -406,7 +409,9 @@ crate fn get_all_types<'tcx>( FnRetTy::Return(ref return_type) => { get_real_types(generics, return_type, tcx, 0, &mut ret_types, cache); if ret_types.is_empty() { - if let Some(kind) = return_type.def_id(cache).map(|did| tcx.def_kind(did).into()) { + if let Some(kind) = + return_type.def_id_no_primitives().map(|did| tcx.def_kind(did).into()) + { ret_types.push(TypeWithKind::from((get_index_type(return_type, vec![]), kind))); } }