2015-04-06 23:17:51 -05:00
|
|
|
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
|
|
|
|
// file at the top-level directory of this distribution and at
|
|
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
|
|
// option. This file may not be copied, modified, or distributed
|
|
|
|
// except according to those terms.
|
|
|
|
|
|
|
|
//! Simplification of where clauses and parameter bounds into a prettier and
|
|
|
|
//! more canonical form.
|
|
|
|
//!
|
|
|
|
//! Currently all cross-crate-inlined function use `middle::ty` to reconstruct
|
|
|
|
//! the AST (e.g. see all of `clean::inline`), but this is not always a
|
|
|
|
//! non-lossy transformation. The current format of storage for where clauses
|
|
|
|
//! for functions and such is simply a list of predicates. One example of this
|
|
|
|
//! is that the AST predicate of:
|
|
|
|
//!
|
|
|
|
//! where T: Trait<Foo=Bar>
|
|
|
|
//!
|
|
|
|
//! is encoded as:
|
|
|
|
//!
|
|
|
|
//! where T: Trait, <T as Trait>::Foo = Bar
|
|
|
|
//!
|
|
|
|
//! This module attempts to reconstruct the original where and/or parameter
|
|
|
|
//! bounds by special casing scenarios such as these. Fun!
|
|
|
|
|
|
|
|
use std::mem;
|
|
|
|
use std::collections::HashMap;
|
|
|
|
|
2015-04-07 14:20:24 -05:00
|
|
|
use rustc::middle::subst;
|
|
|
|
use rustc::middle::ty;
|
|
|
|
use syntax::ast;
|
|
|
|
|
2015-04-06 23:17:51 -05:00
|
|
|
use clean::PathParameters as PP;
|
2015-04-07 14:20:24 -05:00
|
|
|
use clean::WherePredicate as WP;
|
|
|
|
use clean::{self, Clean};
|
|
|
|
use core::DocContext;
|
2015-04-06 23:17:51 -05:00
|
|
|
|
2015-04-07 14:20:24 -05:00
|
|
|
pub fn where_clauses(cx: &DocContext, clauses: Vec<WP>) -> Vec<WP> {
|
2015-04-06 23:17:51 -05:00
|
|
|
// First, partition the where clause into its separate components
|
|
|
|
let mut params = HashMap::new();
|
|
|
|
let mut lifetimes = Vec::new();
|
|
|
|
let mut equalities = Vec::new();
|
|
|
|
let mut tybounds = Vec::new();
|
|
|
|
for clause in clauses {
|
|
|
|
match clause {
|
|
|
|
WP::BoundPredicate { ty, bounds } => {
|
|
|
|
match ty {
|
|
|
|
clean::Generic(s) => params.entry(s).or_insert(Vec::new())
|
|
|
|
.extend(bounds),
|
|
|
|
t => tybounds.push((t, ty_bounds(bounds))),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
WP::RegionPredicate { lifetime, bounds } => {
|
|
|
|
lifetimes.push((lifetime, bounds));
|
|
|
|
}
|
|
|
|
WP::EqPredicate { lhs, rhs } => equalities.push((lhs, rhs)),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Simplify the type parameter bounds on all the generics
|
|
|
|
let mut params = params.into_iter().map(|(k, v)| {
|
|
|
|
(k, ty_bounds(v))
|
|
|
|
}).collect::<HashMap<_, _>>();
|
|
|
|
|
|
|
|
// Look for equality predicates on associated types that can be merged into
|
|
|
|
// general bound predicates
|
|
|
|
equalities.retain(|&(ref lhs, ref rhs)| {
|
|
|
|
let (self_, trait_, name) = match *lhs {
|
|
|
|
clean::QPath { ref self_type, ref trait_, ref name } => {
|
|
|
|
(self_type, trait_, name)
|
|
|
|
}
|
|
|
|
_ => return true,
|
|
|
|
};
|
|
|
|
let generic = match **self_ {
|
|
|
|
clean::Generic(ref s) => s,
|
|
|
|
_ => return true,
|
|
|
|
};
|
|
|
|
let trait_did = match **trait_ {
|
|
|
|
clean::ResolvedPath { did, .. } => did,
|
|
|
|
_ => return true,
|
|
|
|
};
|
|
|
|
let bounds = match params.get_mut(generic) {
|
|
|
|
Some(bound) => bound,
|
|
|
|
None => return true,
|
|
|
|
};
|
|
|
|
!bounds.iter_mut().any(|b| {
|
|
|
|
let trait_ref = match *b {
|
|
|
|
clean::TraitBound(ref mut tr, _) => tr,
|
|
|
|
clean::RegionBound(..) => return false,
|
|
|
|
};
|
|
|
|
let (did, path) = match trait_ref.trait_ {
|
|
|
|
clean::ResolvedPath { did, ref mut path, ..} => (did, path),
|
|
|
|
_ => return false,
|
|
|
|
};
|
2015-04-07 14:20:24 -05:00
|
|
|
// If this QPath's trait `trait_did` is the same as, or a supertrait
|
|
|
|
// of, the bound's trait `did` then we can keep going, otherwise
|
|
|
|
// this is just a plain old equality bound.
|
|
|
|
if !trait_is_same_or_supertrait(cx, did, trait_did) {
|
|
|
|
return false
|
|
|
|
}
|
2015-04-06 23:17:51 -05:00
|
|
|
let last = path.segments.last_mut().unwrap();
|
2015-04-07 14:20:24 -05:00
|
|
|
match last.params {
|
|
|
|
PP::AngleBracketed { ref mut bindings, .. } => {
|
|
|
|
bindings.push(clean::TypeBinding {
|
|
|
|
name: name.clone(),
|
|
|
|
ty: rhs.clone(),
|
|
|
|
});
|
|
|
|
}
|
|
|
|
PP::Parenthesized { ref mut output, .. } => {
|
|
|
|
assert!(output.is_none());
|
|
|
|
*output = Some(rhs.clone());
|
|
|
|
}
|
2015-04-06 23:17:51 -05:00
|
|
|
};
|
|
|
|
true
|
|
|
|
})
|
|
|
|
});
|
|
|
|
|
|
|
|
// And finally, let's reassemble everything
|
|
|
|
let mut clauses = Vec::new();
|
|
|
|
clauses.extend(lifetimes.into_iter().map(|(lt, bounds)| {
|
|
|
|
WP::RegionPredicate { lifetime: lt, bounds: bounds }
|
|
|
|
}));
|
|
|
|
clauses.extend(params.into_iter().map(|(k, v)| {
|
|
|
|
WP::BoundPredicate {
|
|
|
|
ty: clean::Generic(k),
|
|
|
|
bounds: v,
|
|
|
|
}
|
|
|
|
}));
|
|
|
|
clauses.extend(tybounds.into_iter().map(|(ty, bounds)| {
|
|
|
|
WP::BoundPredicate { ty: ty, bounds: bounds }
|
|
|
|
}));
|
|
|
|
clauses.extend(equalities.into_iter().map(|(lhs, rhs)| {
|
|
|
|
WP::EqPredicate { lhs: lhs, rhs: rhs }
|
|
|
|
}));
|
|
|
|
clauses
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn ty_params(mut params: Vec<clean::TyParam>) -> Vec<clean::TyParam> {
|
|
|
|
for param in params.iter_mut() {
|
|
|
|
param.bounds = ty_bounds(mem::replace(&mut param.bounds, Vec::new()));
|
|
|
|
}
|
|
|
|
return params;
|
|
|
|
}
|
|
|
|
|
|
|
|
fn ty_bounds(bounds: Vec<clean::TyParamBound>) -> Vec<clean::TyParamBound> {
|
|
|
|
bounds
|
|
|
|
}
|
2015-04-07 14:20:24 -05:00
|
|
|
|
|
|
|
fn trait_is_same_or_supertrait(cx: &DocContext, child: ast::DefId,
|
|
|
|
trait_: ast::DefId) -> bool {
|
|
|
|
if child == trait_ {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
let def = ty::lookup_trait_def(cx.tcx(), child);
|
|
|
|
let predicates = ty::lookup_predicates(cx.tcx(), child);
|
|
|
|
let generics = (&def.generics, &predicates, subst::TypeSpace).clean(cx);
|
|
|
|
generics.where_predicates.iter().filter_map(|pred| {
|
|
|
|
match *pred {
|
|
|
|
clean::WherePredicate::BoundPredicate {
|
|
|
|
ty: clean::Generic(ref s),
|
|
|
|
ref bounds
|
|
|
|
} if *s == "Self" => Some(bounds),
|
|
|
|
_ => None,
|
|
|
|
}
|
|
|
|
}).flat_map(|bounds| bounds.iter()).any(|bound| {
|
|
|
|
let poly_trait = match *bound {
|
|
|
|
clean::TraitBound(ref t, _) => t,
|
|
|
|
_ => return false,
|
|
|
|
};
|
|
|
|
match poly_trait.trait_ {
|
|
|
|
clean::ResolvedPath { did, .. } => {
|
|
|
|
trait_is_same_or_supertrait(cx, did, trait_)
|
|
|
|
}
|
|
|
|
_ => false,
|
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|