1 use crate::rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt;
3 use rustc_hir::def_id::LOCAL_CRATE;
4 use rustc_infer::infer::{InferOk, TyCtxtInferExt};
5 use rustc_infer::traits;
6 use rustc_middle::ty::subst::Subst;
7 use rustc_middle::ty::{ToPredicate, WithConstness};
8 use rustc_span::DUMMY_SP;
12 crate struct BlanketImplFinder<'a, 'tcx> {
13 crate cx: &'a core::DocContext<'tcx>,
16 impl<'a, 'tcx> BlanketImplFinder<'a, 'tcx> {
17 crate fn new(cx: &'a core::DocContext<'tcx>) -> Self {
18 BlanketImplFinder { cx }
21 // FIXME(eddyb) figure out a better way to pass information about
22 // parametrization of `ty` than `param_env_def_id`.
23 crate fn get_blanket_impls(&self, ty: Ty<'tcx>, param_env_def_id: DefId) -> Vec<Item> {
24 let param_env = self.cx.tcx.param_env(param_env_def_id);
26 debug!("get_blanket_impls({:?})", ty);
27 let mut impls = Vec::new();
28 for &trait_def_id in self.cx.tcx.all_traits(LOCAL_CRATE).iter() {
29 if !self.cx.renderinfo.borrow().access_levels.is_public(trait_def_id)
30 || self.cx.generated_synthetics.borrow_mut().get(&(ty, trait_def_id)).is_some()
34 self.cx.tcx.for_each_relevant_impl(trait_def_id, ty, |impl_def_id| {
36 "get_blanket_impls: Considering impl for trait '{:?}' {:?}",
37 trait_def_id, impl_def_id
39 let trait_ref = self.cx.tcx.impl_trait_ref(impl_def_id).unwrap();
40 let may_apply = self.cx.tcx.infer_ctxt().enter(|infcx| {
41 match trait_ref.self_ty().kind() {
46 let substs = infcx.fresh_substs_for_item(DUMMY_SP, param_env_def_id);
47 let ty = ty.subst(infcx.tcx, substs);
48 let param_env = param_env.subst(infcx.tcx, substs);
50 let impl_substs = infcx.fresh_substs_for_item(DUMMY_SP, impl_def_id);
51 let trait_ref = trait_ref.subst(infcx.tcx, impl_substs);
53 // Require the type the impl is implemented on to match
54 // our type, and ignore the impl if there was a mismatch.
55 let cause = traits::ObligationCause::dummy();
56 let eq_result = infcx.at(&cause, param_env).eq(trait_ref.self_ty(), ty);
57 if let Ok(InferOk { value: (), obligations }) = eq_result {
58 // FIXME(eddyb) ignoring `obligations` might cause false positives.
62 "invoking predicate_may_hold: param_env={:?}, trait_ref={:?}, ty={:?}",
63 param_env, trait_ref, ty
68 .predicates_of(impl_def_id)
69 .instantiate(self.cx.tcx, impl_substs)
72 .chain(Some(trait_ref.without_const().to_predicate(infcx.tcx)));
73 for predicate in predicates {
74 debug!("testing predicate {:?}", predicate);
75 let obligation = traits::Obligation::new(
76 traits::ObligationCause::dummy(),
80 match infcx.evaluate_obligation(&obligation) {
81 Ok(eval_result) if eval_result.may_apply() => {}
82 Err(traits::OverflowError) => {}
94 "get_blanket_impls: found applicable impl: {} for trait_ref={:?}, ty={:?}",
95 may_apply, trait_ref, ty
101 self.cx.generated_synthetics.borrow_mut().insert((ty, trait_def_id));
102 let provided_trait_methods = self
105 .provided_trait_methods(trait_def_id)
106 .map(|meth| meth.ident.name)
110 source: self.cx.tcx.def_span(impl_def_id).clean(self.cx),
112 attrs: Default::default(),
113 visibility: Inherited,
114 def_id: self.cx.next_def_id(impl_def_id.krate),
115 kind: box ImplItem(Impl {
116 unsafety: hir::Unsafety::Normal,
118 self.cx.tcx.generics_of(impl_def_id),
119 self.cx.tcx.explicit_predicates_of(impl_def_id),
122 provided_trait_methods,
123 // FIXME(eddyb) compute both `trait_` and `for_` from
124 // the post-inference `trait_ref`, as it's more accurate.
125 trait_: Some(trait_ref.clean(self.cx).get_trait_type().unwrap()),
126 for_: ty.clean(self.cx),
130 .associated_items(impl_def_id)
131 .in_definition_order()
134 negative_polarity: false,
136 blanket_impl: Some(trait_ref.self_ty().clean(self.cx)),