rustdoc/clean/
blanket_impl.rs1use rustc_hir as hir;
2use rustc_infer::infer::{DefineOpaqueTypes, InferOk, TyCtxtInferExt};
3use rustc_infer::traits;
4use rustc_middle::ty::{self, TypingMode, Upcast};
5use rustc_span::DUMMY_SP;
6use rustc_span::def_id::DefId;
7use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt;
8use thin_vec::ThinVec;
9use tracing::{debug, instrument, trace};
10
11use crate::clean;
12use crate::clean::{
13 clean_middle_assoc_item, clean_middle_ty, clean_trait_ref_with_constraints, clean_ty_generics,
14};
15use crate::core::DocContext;
16
17#[instrument(level = "debug", skip(cx))]
18pub(crate) fn synthesize_blanket_impls(
19 cx: &mut DocContext<'_>,
20 item_def_id: DefId,
21) -> Vec<clean::Item> {
22 let tcx = cx.tcx;
23 let ty = tcx.type_of(item_def_id);
24
25 let mut blanket_impls = Vec::new();
26 for trait_def_id in tcx.all_traits() {
27 if !cx.cache.effective_visibilities.is_reachable(tcx, trait_def_id)
28 || cx.generated_synthetics.contains(&(ty.skip_binder(), trait_def_id))
29 {
30 continue;
31 }
32 let trait_impls = tcx.trait_impls_of(trait_def_id);
34 'blanket_impls: for &impl_def_id in trait_impls.blanket_impls() {
35 trace!("considering impl `{impl_def_id:?}` for trait `{trait_def_id:?}`");
36
37 let trait_ref = tcx.impl_trait_ref(impl_def_id).unwrap();
38 if !matches!(trait_ref.skip_binder().self_ty().kind(), ty::Param(_)) {
39 continue;
40 }
41 let infcx = tcx.infer_ctxt().build(TypingMode::non_body_analysis());
42 let args = infcx.fresh_args_for_item(DUMMY_SP, item_def_id);
43 let impl_ty = ty.instantiate(tcx, args);
44 let param_env = ty::ParamEnv::empty();
45
46 let impl_args = infcx.fresh_args_for_item(DUMMY_SP, impl_def_id);
47 let impl_trait_ref = trait_ref.instantiate(tcx, impl_args);
48
49 let Ok(eq_result) = infcx.at(&traits::ObligationCause::dummy(), param_env).eq(
52 DefineOpaqueTypes::Yes,
53 impl_trait_ref.self_ty(),
54 impl_ty,
55 ) else {
56 continue;
57 };
58 let InferOk { value: (), obligations } = eq_result;
59 drop(obligations);
61
62 let predicates = tcx
63 .predicates_of(impl_def_id)
64 .instantiate(tcx, impl_args)
65 .predicates
66 .into_iter()
67 .chain(Some(impl_trait_ref.upcast(tcx)));
68 for predicate in predicates {
69 let obligation = traits::Obligation::new(
70 tcx,
71 traits::ObligationCause::dummy(),
72 param_env,
73 predicate,
74 );
75 match infcx.evaluate_obligation(&obligation) {
76 Ok(eval_result) if eval_result.may_apply() => {}
77 Err(traits::OverflowError::Canonical) => {}
78 _ => continue 'blanket_impls,
79 }
80 }
81 debug!("found applicable impl for trait ref {trait_ref:?}");
82
83 cx.generated_synthetics.insert((ty.skip_binder(), trait_def_id));
84
85 blanket_impls.push(clean::Item {
86 inner: Box::new(clean::ItemInner {
87 name: None,
88 item_id: clean::ItemId::Blanket { impl_id: impl_def_id, for_: item_def_id },
89 attrs: Default::default(),
90 stability: None,
91 kind: clean::ImplItem(Box::new(clean::Impl {
92 safety: hir::Safety::Safe,
93 generics: clean_ty_generics(cx, impl_def_id),
94 trait_: Some(clean_trait_ref_with_constraints(
97 cx,
98 ty::Binder::dummy(trait_ref.instantiate_identity()),
99 ThinVec::new(),
100 )),
101 for_: clean_middle_ty(
102 ty::Binder::dummy(ty.instantiate_identity()),
103 cx,
104 None,
105 None,
106 ),
107 items: tcx
108 .associated_items(impl_def_id)
109 .in_definition_order()
110 .filter(|item| !item.is_impl_trait_in_trait())
111 .map(|item| clean_middle_assoc_item(item, cx))
112 .collect(),
113 polarity: ty::ImplPolarity::Positive,
114 kind: clean::ImplKind::Blanket(Box::new(clean_middle_ty(
115 ty::Binder::dummy(trait_ref.instantiate_identity().self_ty()),
116 cx,
117 None,
118 None,
119 ))),
120 })),
121 cfg: None,
122 inline_stmt_id: None,
123 }),
124 });
125 }
126 }
127
128 blanket_impls
129}