From c47c2c6016f16476138da8f6f7f3f384e5d32fe3 Mon Sep 17 00:00:00 2001 From: Joshua Nelson Date: Sun, 24 Jan 2021 13:42:14 -0500 Subject: [PATCH] Remove unnecessary `self_ty` parameter to `get_blanket_impls` It can be calculated when necessary at the callsite, there's no need to pass it separately. This also renames `param_env_def_id` to `item_def_id`. --- src/librustdoc/clean/auto_trait.rs | 53 +++++++++----------- src/librustdoc/clean/blanket_impl.rs | 9 ++-- src/librustdoc/clean/utils.rs | 9 ++-- src/librustdoc/passes/collect_trait_impls.rs | 10 +--- 4 files changed, 33 insertions(+), 48 deletions(-) diff --git a/src/librustdoc/clean/auto_trait.rs b/src/librustdoc/clean/auto_trait.rs index a24cb0a0f93..c23c087be41 100644 --- a/src/librustdoc/clean/auto_trait.rs +++ b/src/librustdoc/clean/auto_trait.rs @@ -34,7 +34,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> { ty: Ty<'tcx>, trait_def_id: DefId, param_env: ty::ParamEnv<'tcx>, - param_env_def_id: DefId, + item_def_id: DefId, f: &auto_trait::AutoTraitFinder<'tcx>, // If this is set, show only negative trait implementations, not positive ones. discard_positive_impl: bool, @@ -50,7 +50,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> { let region_data = info.region_data; let names_map = tcx - .generics_of(param_env_def_id) + .generics_of(item_def_id) .params .iter() .filter_map(|param| match param.kind { @@ -62,16 +62,16 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> { let lifetime_predicates = Self::handle_lifetimes(®ion_data, &names_map); let new_generics = self.param_env_to_generics( infcx.tcx, - param_env_def_id, + item_def_id, info.full_user_env, lifetime_predicates, info.vid_to_region, ); debug!( - "find_auto_trait_generics(param_env_def_id={:?}, trait_def_id={:?}): \ + "find_auto_trait_generics(item_def_id={:?}, trait_def_id={:?}): \ finished with {:?}", - param_env_def_id, trait_def_id, new_generics + item_def_id, trait_def_id, new_generics ); new_generics @@ -101,7 +101,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> { // Instead, we generate `impl !Send for Foo`, which better // expresses the fact that `Foo` never implements `Send`, // regardless of the choice of `T`. - let params = (tcx.generics_of(param_env_def_id), ty::GenericPredicates::default()) + let params = (tcx.generics_of(item_def_id), ty::GenericPredicates::default()) .clean(self.cx) .params; @@ -115,7 +115,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> { name: None, attrs: Default::default(), visibility: Inherited, - def_id: self.cx.next_def_id(param_env_def_id.krate), + def_id: self.cx.next_def_id(item_def_id.krate), kind: box ImplItem(Impl { unsafety: hir::Unsafety::Normal, generics: new_generics, @@ -130,26 +130,25 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> { }) } - // FIXME(eddyb) figure out a better way to pass information about - // parametrization of `ty` than `param_env_def_id`. - crate fn get_auto_trait_impls(&mut self, ty: Ty<'tcx>, param_env_def_id: DefId) -> Vec { + crate fn get_auto_trait_impls(&mut self, item_def_id: DefId) -> Vec { let tcx = self.cx.tcx; - let param_env = tcx.param_env(param_env_def_id); - let f = auto_trait::AutoTraitFinder::new(self.cx.tcx); + let param_env = tcx.param_env(item_def_id); + let ty = tcx.type_of(item_def_id); + let f = auto_trait::AutoTraitFinder::new(tcx); debug!("get_auto_trait_impls({:?})", ty); let auto_traits: Vec<_> = self.cx.auto_traits.iter().cloned().collect(); let mut auto_traits: Vec = auto_traits .into_iter() .filter_map(|trait_def_id| { - self.generate_for_trait(ty, trait_def_id, param_env, param_env_def_id, &f, false) + self.generate_for_trait(ty, trait_def_id, param_env, item_def_id, &f, false) }) .collect(); // We are only interested in case the type *doesn't* implement the Sized trait. - if !ty.is_sized(self.cx.tcx.at(rustc_span::DUMMY_SP), param_env) { + if !ty.is_sized(tcx.at(rustc_span::DUMMY_SP), param_env) { // In case `#![no_core]` is used, `sized_trait` returns nothing. - if let Some(item) = self.cx.tcx.lang_items().sized_trait().and_then(|sized_trait_did| { - self.generate_for_trait(ty, sized_trait_did, param_env, param_env_def_id, &f, true) + if let Some(item) = tcx.lang_items().sized_trait().and_then(|sized_trait_did| { + self.generate_for_trait(ty, sized_trait_did, param_env, item_def_id, &f, true) }) { auto_traits.push(item); } @@ -445,15 +444,15 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> { fn param_env_to_generics( &mut self, tcx: TyCtxt<'tcx>, - param_env_def_id: DefId, + item_def_id: DefId, param_env: ty::ParamEnv<'tcx>, mut existing_predicates: Vec, vid_to_region: FxHashMap>, ) -> Generics { debug!( - "param_env_to_generics(param_env_def_id={:?}, param_env={:?}, \ + "param_env_to_generics(item_def_id={:?}, param_env={:?}, \ existing_predicates={:?})", - param_env_def_id, param_env, existing_predicates + item_def_id, param_env, existing_predicates ); // The `Sized` trait must be handled specially, since we only display it when @@ -463,7 +462,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> { let mut replacer = RegionReplacer { vid_to_region: &vid_to_region, tcx }; let orig_bounds: FxHashSet<_> = - self.cx.tcx.param_env(param_env_def_id).caller_bounds().iter().collect(); + self.cx.tcx.param_env(item_def_id).caller_bounds().iter().collect(); let clean_where_predicates = param_env .caller_bounds() .iter() @@ -477,14 +476,11 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> { .map(|p| p.fold_with(&mut replacer)); let mut generic_params = - (tcx.generics_of(param_env_def_id), tcx.explicit_predicates_of(param_env_def_id)) + (tcx.generics_of(item_def_id), tcx.explicit_predicates_of(item_def_id)) .clean(self.cx) .params; - debug!( - "param_env_to_generics({:?}): generic_params={:?}", - param_env_def_id, generic_params - ); + debug!("param_env_to_generics({:?}): generic_params={:?}", item_def_id, generic_params); let mut has_sized = FxHashSet::default(); let mut ty_to_bounds: FxHashMap<_, FxHashSet<_>> = Default::default(); @@ -648,13 +644,10 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> { .or_default() .insert(*trait_.clone()); } - _ => panic!( - "Unexpected trait {:?} for {:?}", - trait_, param_env_def_id, - ), + _ => panic!("Unexpected trait {:?} for {:?}", trait_, item_def_id), } } - _ => panic!("Unexpected LHS {:?} for {:?}", lhs, param_env_def_id), + _ => panic!("Unexpected LHS {:?} for {:?}", lhs, item_def_id), } } }; diff --git a/src/librustdoc/clean/blanket_impl.rs b/src/librustdoc/clean/blanket_impl.rs index 94b82037e75..5cda4cc5ada 100644 --- a/src/librustdoc/clean/blanket_impl.rs +++ b/src/librustdoc/clean/blanket_impl.rs @@ -14,10 +14,9 @@ crate struct BlanketImplFinder<'a, 'tcx> { } impl<'a, 'tcx> BlanketImplFinder<'a, 'tcx> { - // FIXME(eddyb) figure out a better way to pass information about - // parametrization of `ty` than `param_env_def_id`. - crate fn get_blanket_impls(&mut self, ty: Ty<'tcx>, param_env_def_id: DefId) -> Vec { - let param_env = self.cx.tcx.param_env(param_env_def_id); + crate fn get_blanket_impls(&mut self, item_def_id: DefId) -> Vec { + let param_env = self.cx.tcx.param_env(item_def_id); + let ty = self.cx.tcx.type_of(item_def_id); debug!("get_blanket_impls({:?})", ty); let mut impls = Vec::new(); @@ -39,7 +38,7 @@ impl<'a, 'tcx> BlanketImplFinder<'a, 'tcx> { _ => return false, } - let substs = infcx.fresh_substs_for_item(DUMMY_SP, param_env_def_id); + let substs = infcx.fresh_substs_for_item(DUMMY_SP, item_def_id); let ty = ty.subst(infcx.tcx, substs); let param_env = param_env.subst(infcx.tcx, substs); diff --git a/src/librustdoc/clean/utils.rs b/src/librustdoc/clean/utils.rs index d2eee49f0c9..12558c3c5a7 100644 --- a/src/librustdoc/clean/utils.rs +++ b/src/librustdoc/clean/utils.rs @@ -13,7 +13,7 @@ use rustc_hir::def::{DefKind, Res}; use rustc_hir::def_id::{DefId, LOCAL_CRATE}; use rustc_middle::mir::interpret::ConstValue; use rustc_middle::ty::subst::{GenericArgKind, SubstsRef}; -use rustc_middle::ty::{self, DefIdTree, Ty, TyCtxt}; +use rustc_middle::ty::{self, DefIdTree, TyCtxt}; use rustc_span::symbol::{kw, sym, Symbol}; use std::mem; @@ -426,19 +426,18 @@ crate fn resolve_type(cx: &mut DocContext<'_>, path: Path, id: hir::HirId) -> Ty crate fn get_auto_trait_and_blanket_impls( cx: &mut DocContext<'tcx>, - ty: Ty<'tcx>, - param_env_def_id: DefId, + item_def_id: DefId, ) -> impl Iterator { let auto_impls = cx .sess() .prof .generic_activity("get_auto_trait_impls") - .run(|| AutoTraitFinder::new(cx).get_auto_trait_impls(ty, param_env_def_id)); + .run(|| AutoTraitFinder::new(cx).get_auto_trait_impls(item_def_id)); let blanket_impls = cx .sess() .prof .generic_activity("get_blanket_impls") - .run(|| BlanketImplFinder { cx }.get_blanket_impls(ty, param_env_def_id)); + .run(|| BlanketImplFinder { cx }.get_blanket_impls(item_def_id)); auto_impls.into_iter().chain(blanket_impls) } diff --git a/src/librustdoc/passes/collect_trait_impls.rs b/src/librustdoc/passes/collect_trait_impls.rs index 0271a5b78a7..0e84a510177 100644 --- a/src/librustdoc/passes/collect_trait_impls.rs +++ b/src/librustdoc/passes/collect_trait_impls.rs @@ -46,9 +46,7 @@ crate fn collect_trait_impls(krate: Crate, cx: &mut DocContext<'_>) -> Crate { // FIXME(eddyb) is this `doc(hidden)` check needed? if !cx.tcx.get_attrs(def_id).lists(sym::doc).has_word(sym::hidden) { - let self_ty = cx.tcx.type_of(def_id); - let impls = get_auto_trait_and_blanket_impls(cx, self_ty, def_id); - + let impls = get_auto_trait_and_blanket_impls(cx, def_id); new_items.extend(impls.filter(|i| cx.renderinfo.inlined.insert(i.def_id))); } }); @@ -170,11 +168,7 @@ impl<'a, 'tcx> DocFolder for SyntheticImplCollector<'a, 'tcx> { if i.is_struct() || i.is_enum() || i.is_union() { // FIXME(eddyb) is this `doc(hidden)` check needed? if !self.cx.tcx.get_attrs(i.def_id).lists(sym::doc).has_word(sym::hidden) { - self.impls.extend(get_auto_trait_and_blanket_impls( - self.cx, - self.cx.tcx.type_of(i.def_id), - i.def_id, - )); + self.impls.extend(get_auto_trait_and_blanket_impls(self.cx, i.def_id)); } }