1 //! Simplification of where-clauses and parameter bounds into a prettier and
2 //! more canonical form.
4 //! Currently all cross-crate-inlined function use `rustc_middle::ty` to reconstruct
5 //! the AST (e.g., see all of `clean::inline`), but this is not always a
6 //! non-lossy transformation. The current format of storage for where-clauses
7 //! for functions and such is simply a list of predicates. One example of this
8 //! is that the AST predicate of: `where T: Trait<Foo = Bar>` is encoded as:
9 //! `where T: Trait, <T as Trait>::Foo = Bar`.
11 //! This module attempts to reconstruct the original where and/or parameter
12 //! bounds by special casing scenarios such as these. Fun!
14 use std::collections::BTreeMap;
16 use rustc_hir::def_id::DefId;
18 use rustc_span::Symbol;
21 use crate::clean::GenericArgs as PP;
22 use crate::clean::WherePredicate as WP;
23 use crate::core::DocContext;
25 crate fn where_clauses(cx: &DocContext<'_>, clauses: Vec<WP>) -> Vec<WP> {
26 // First, partition the where clause into its separate components
27 let mut params: BTreeMap<_, Vec<_>> = BTreeMap::new();
28 let mut lifetimes = Vec::new();
29 let mut equalities = Vec::new();
30 let mut tybounds = Vec::new();
32 for clause in clauses {
34 WP::BoundPredicate { ty, bounds } => match ty {
35 clean::Generic(s) => params.entry(s).or_default().extend(bounds),
36 t => tybounds.push((t, bounds)),
38 WP::RegionPredicate { lifetime, bounds } => {
39 lifetimes.push((lifetime, bounds));
41 WP::EqPredicate { lhs, rhs } => equalities.push((lhs, rhs)),
45 // Look for equality predicates on associated types that can be merged into
46 // general bound predicates
47 equalities.retain(|&(ref lhs, ref rhs)| {
48 let (self_, trait_did, name) = if let Some(p) = lhs.projection() {
53 let generic = match self_ {
54 clean::Generic(s) => s,
57 let bounds = match params.get_mut(generic) {
62 merge_bounds(cx, bounds, trait_did, name, rhs)
65 // And finally, let's reassemble everything
66 let mut clauses = Vec::new();
68 lifetimes.into_iter().map(|(lt, bounds)| WP::RegionPredicate { lifetime: lt, bounds }),
71 params.into_iter().map(|(k, v)| WP::BoundPredicate { ty: clean::Generic(k), bounds: v }),
73 clauses.extend(tybounds.into_iter().map(|(ty, bounds)| WP::BoundPredicate { ty, bounds }));
74 clauses.extend(equalities.into_iter().map(|(lhs, rhs)| WP::EqPredicate { lhs, rhs }));
78 crate fn merge_bounds(
79 cx: &clean::DocContext<'_>,
80 bounds: &mut Vec<clean::GenericBound>,
85 !bounds.iter_mut().any(|b| {
86 let trait_ref = match *b {
87 clean::GenericBound::TraitBound(ref mut tr, _) => tr,
88 clean::GenericBound::Outlives(..) => return false,
90 let (did, path) = match trait_ref.trait_ {
91 clean::ResolvedPath { did, ref mut path, .. } => (did, path),
94 // If this QPath's trait `trait_did` is the same as, or a supertrait
95 // of, the bound's trait `did` then we can keep going, otherwise
96 // this is just a plain old equality bound.
97 if !trait_is_same_or_supertrait(cx, did, trait_did) {
100 let last = path.segments.last_mut().expect("segments were empty");
102 PP::AngleBracketed { ref mut bindings, .. } => {
103 bindings.push(clean::TypeBinding {
105 kind: clean::TypeBindingKind::Equality { ty: rhs.clone() },
108 PP::Parenthesized { ref mut output, .. } => match output {
109 Some(o) => assert_eq!(o, rhs),
111 if *rhs != clean::Type::Tuple(Vec::new()) {
112 *output = Some(rhs.clone());
121 fn trait_is_same_or_supertrait(cx: &DocContext<'_>, child: DefId, trait_: DefId) -> bool {
125 let predicates = cx.tcx.super_predicates_of(child);
126 debug_assert!(cx.tcx.generics_of(child).has_self);
127 let self_ty = cx.tcx.types.self_param;
131 .filter_map(|(pred, _)| {
132 if let ty::PredicateKind::Trait(pred, _) = pred.kind().skip_binder() {
133 if pred.trait_ref.self_ty() == self_ty { Some(pred.def_id()) } else { None }
138 .any(|did| trait_is_same_or_supertrait(cx, did, trait_))