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..1dda80ff38c58 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(); @@ -335,31 +338,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 +381,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,7 +391,7 @@ 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(..));`. @@ -396,7 +407,7 @@ 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()) 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); } } }