nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-23 15:23:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge generics and where predicates and prevent duplicates in where predicates

Browse Source
This commit is contained in:
Guillaume Gomez 2022-12-02 19:36:20 +01:00
parent 11663b1b48
commit af45040acd
1 changed files with 93 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

128
src/librustdoc/clean/mod.rs
View File

@ -12,7 +12,7 @@ pub(crate) mod utils;
use rustc_ast as ast;
use rustc_attr as attr;
use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexSet};
use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet, IndexEntry};
use rustc_hir as hir;
use rustc_hir::def::{CtorKind, DefKind, Res};
use rustc_hir::def_id::{DefId, LOCAL_CRATE};
@ -598,47 +598,105 @@ pub(crate) fn clean_generics<'tcx>(
})
.collect::<Vec<_>>();
let mut params = ThinVec::with_capacity(gens.params.len());
for p in gens.params.iter().filter(|p| !is_impl_trait(p) && !is_elided_lifetime(p)) {
let p = clean_generic_param(cx, Some(gens), p);
params.push(p);
}
params.extend(impl_trait_params);
let mut generics = Generics {
params,
where_predicates: gens
.predicates
.iter()
.filter_map(|x| clean_where_predicate(x, cx))
.collect(),
};
// Some duplicates are generated for ?Sized bounds between type params and where
// predicates. The point in here is to move the bounds definitions from type params
// to where predicates when such cases occur.
for where_pred in &mut generics.where_predicates {
match *where_pred {
WherePredicate::BoundPredicate { ty: Generic(ref name), ref mut bounds, .. } => {
if bounds.is_empty() {
for param in &mut generics.params {
match param.kind {
GenericParamDefKind::Lifetime { .. } => {}
GenericParamDefKind::Type { bounds: ref mut ty_bounds, .. } => {
if &param.name == name {
mem::swap(bounds, ty_bounds);
break;
}
let mut bound_predicates = FxIndexMap::default();
let mut region_predicates = FxIndexMap::default();
let mut eq_predicates = ThinVec::default();
for pred in gens.predicates.iter().filter_map(|x| clean_where_predicate(x, cx)) {
match pred {
WherePredicate::BoundPredicate { ty, bounds, bound_params } => {
match bound_predicates.entry(ty) {
IndexEntry::Vacant(v) => {
v.insert((bounds, bound_params));
}
IndexEntry::Occupied(mut o) => {
// we merge both bounds.
for bound in bounds {
if !o.get().0.contains(&bound) {
o.get_mut().0.push(bound);
}
}
for bound_param in bound_params {
if !o.get().1.contains(&bound_param) {
o.get_mut().1.push(bound_param);
}
GenericParamDefKind::Const { .. } => {}
}
}
}
}
_ => continue,
WherePredicate::RegionPredicate { lifetime, bounds } => {
match region_predicates.entry(lifetime) {
IndexEntry::Vacant(v) => {
v.insert(bounds);
}
IndexEntry::Occupied(mut o) => {
// we merge both bounds.
for bound in bounds {
if !o.get().contains(&bound) {
o.get_mut().push(bound);
}
}
}
}
}
WherePredicate::EqPredicate { lhs, rhs, bound_params } => {
eq_predicates.push(WherePredicate::EqPredicate { lhs, rhs, bound_params });
}
}
}
generics
let mut params = ThinVec::with_capacity(gens.params.len());
// In this loop, we gather the generic parameters (`<'a, B: 'a>`) and check if they have
// bounds in the where predicates. If so, we move their bounds into the where predicates
// while also preventing duplicates.
for p in gens.params.iter().filter(|p| !is_impl_trait(p) && !is_elided_lifetime(p)) {
let mut p = clean_generic_param(cx, Some(gens), p);
match &mut p.kind {
GenericParamDefKind::Lifetime { ref mut outlives } => {
if let Some(region_pred) = region_predicates.get_mut(&Lifetime(p.name)) {
// We merge bounds in the `where` clause.
for outlive in outlives.drain(..) {
let outlive = GenericBound::Outlives(outlive);
if !region_pred.contains(&outlive) {
region_pred.push(outlive);
}
}
}
}
GenericParamDefKind::Type { bounds, synthetic: false, .. } => {
if let Some(bound_pred) = bound_predicates.get_mut(&Type::Generic(p.name)) {
// We merge bounds in the `where` clause.
for bound in bounds.drain(..) {
if !bound_pred.0.contains(&bound) {
bound_pred.0.push(bound);
}
}
}
}
GenericParamDefKind::Type { .. } | GenericParamDefKind::Const { .. } => {
// nothing to do here.
}
}
params.push(p);
}
params.extend(impl_trait_params);
Generics {
params,
where_predicates: bound_predicates
.into_iter()
.map(|(ty, (bounds, bound_params))| WherePredicate::BoundPredicate {
ty,
bounds,
bound_params,
})
.chain(
region_predicates
.into_iter()
.map(|(lifetime, bounds)| WherePredicate::RegionPredicate { lifetime, bounds }),
)
.chain(eq_predicates.into_iter())
.collect(),
}
}
fn clean_ty_generics<'tcx>(