Skip to content

Commit

Permalink
Rollup merge of #112920 - fmease:rustdoc-fix-112904, r=GuillaumeGomez
Browse files Browse the repository at this point in the history 
rustdoc: render generic params & where-clauses of cross-crate assoc tys in impls

We used to only ever render generic parameters & where-clauses of cross-crate associated types when the item was located inside of a trait and we used to just drop them when it was inside of an impl block (trait or inherent).

Fixes #112904.

`@rustbot` label A-cross-crate-reexports
  • Loading branch information
@TaKO8Ki
TaKO8Ki authored Jun 26, 2023
2 parents c6a4d44 + c643bed commit 40e3fcf
Show file tree
Hide file tree
Showing 3 changed files with 74 additions and 43 deletions.
88 changes: 45 additions & 43 deletions src/librustdoc/clean/mod.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1352,21 +1352,53 @@ pub(crate) fn clean_middle_assoc_item<'tcx>(
}
}

let mut predicates = tcx.explicit_predicates_of(assoc_item.def_id).predicates;
if let ty::TraitContainer = assoc_item.container {
let bounds = tcx
.explicit_item_bounds(assoc_item.def_id)
.subst_identity_iter_copied()
.map(|(c, s)| (c.as_predicate(), s));
let predicates = tcx.explicit_predicates_of(assoc_item.def_id).predicates;
let predicates =
tcx.arena.alloc_from_iter(bounds.chain(predicates.iter().copied()));
let mut generics = clean_ty_generics(
cx,
tcx.generics_of(assoc_item.def_id),
ty::GenericPredicates { parent: None, predicates },
);
// Filter out the bounds that are (likely?) directly attached to the associated type,
// as opposed to being located in the where clause.
predicates = tcx.arena.alloc_from_iter(bounds.chain(predicates.iter().copied()));
}
let mut generics = clean_ty_generics(
cx,
tcx.generics_of(assoc_item.def_id),
ty::GenericPredicates { parent: None, predicates },
);
// Move bounds that are (likely) directly attached to the parameters of the
// (generic) associated type from the where clause to the respective parameter.
// There is no guarantee that this is what the user actually wrote but we have
// no way of knowing.
let mut where_predicates = ThinVec::new();
for mut pred in generics.where_predicates {
if let WherePredicate::BoundPredicate { ty: Generic(arg), bounds, .. } = &mut pred
&& let Some(GenericParamDef {
kind: GenericParamDefKind::Type { bounds: param_bounds, .. },
..
}) = generics.params.iter_mut().find(|param| &param.name == arg)
{
param_bounds.append(bounds);
} else if let WherePredicate::RegionPredicate { lifetime: Lifetime(arg), bounds } = &mut pred
&& let Some(GenericParamDef {
kind: GenericParamDefKind::Lifetime { outlives: param_bounds },
..
}) = generics.params.iter_mut().find(|param| &param.name == arg)
{
param_bounds.extend(bounds.drain(..).map(|bound| match bound {
GenericBound::Outlives(lifetime) => lifetime,
_ => unreachable!(),
}));
} else {
where_predicates.push(pred);
}
}
generics.where_predicates = where_predicates;

if let ty::TraitContainer = assoc_item.container {
// Move bounds that are (likely) directly attached to the associated type
// from the where-clause to the associated type.
// There is no guarantee that this is what the user actually wrote but we have
// no way of knowing.
let mut bounds: Vec<GenericBound> = Vec::new();
generics.where_predicates.retain_mut(|pred| match *pred {
WherePredicate::BoundPredicate {
Expand Down Expand Up @@ -1423,33 +1455,6 @@ pub(crate) fn clean_middle_assoc_item<'tcx>(
}
None => bounds.push(GenericBound::maybe_sized(cx)),
}
// Move bounds that are (likely) directly attached to the parameters of the
// (generic) associated type from the where clause to the respective parameter.
// There is no guarantee that this is what the user actually wrote but we have
// no way of knowing.
let mut where_predicates = ThinVec::new();
for mut pred in generics.where_predicates {
if let WherePredicate::BoundPredicate { ty: Generic(arg), bounds, .. } = &mut pred
&& let Some(GenericParamDef {
kind: GenericParamDefKind::Type { bounds: param_bounds, .. },
..
}) = generics.params.iter_mut().find(|param| &param.name == arg)
{
param_bounds.append(bounds);
} else if let WherePredicate::RegionPredicate { lifetime: Lifetime(arg), bounds } = &mut pred
&& let Some(GenericParamDef {
kind: GenericParamDefKind::Lifetime { outlives: param_bounds },
..
}) = generics.params.iter_mut().find(|param| &param.name == arg) {
param_bounds.extend(bounds.drain(..).map(|bound| match bound {
GenericBound::Outlives(lifetime) => lifetime,
_ => unreachable!(),
}));
} else {
where_predicates.push(pred);
}
}
generics.where_predicates = where_predicates;

if tcx.defaultness(assoc_item.def_id).has_value() {
AssocTypeItem(
Expand All @@ -1461,7 +1466,6 @@ pub(crate) fn clean_middle_assoc_item<'tcx>(
None,
),
generics,
// FIXME: should we obtain the Type from HIR and pass it on here?
item_type: None,
}),
bounds,
Expand All @@ -1470,7 +1474,6 @@ pub(crate) fn clean_middle_assoc_item<'tcx>(
TyAssocTypeItem(generics, bounds)
}
} else {
// FIXME: when could this happen? Associated items in inherent impls?
AssocTypeItem(
Box::new(Typedef {
type_: clean_middle_ty(
Expand All @@ -1479,12 +1482,11 @@ pub(crate) fn clean_middle_assoc_item<'tcx>(
Some(assoc_item.def_id),
None,
),
generics: Generics {
params: ThinVec::new(),
where_predicates: ThinVec::new(),
},
generics,
item_type: None,
}),
// Associated types inside trait or inherent impls are not allowed to have
// item bounds. Thus we don't attempt to move any bounds there.
Vec::new(),
)
}
Expand Down
12 changes: 12 additions & 0 deletions tests/rustdoc/inline_cross/assoc_item_trait_bounds.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -42,3 +42,15 @@ pub use aux::Main;
// @has main/trait.Aid.html
// @has - '//*[@id="associatedtype.Result"]' "type Result<'inter: 'src>"
pub use aux::Aid;

// Below, ensure that we correctly display generic parameters and where-clauses on
// associated types inside trait *impls*. More particularly, check that we don't render
// any bounds (here `Self::Alias<T>: ...`) as item bounds unlike all the trait test cases above.

// @has main/struct.Implementor.html
// @has - '//*[@id="associatedtype.Alias"]' \
// "type Alias<T: Eq> = T \
// where \
// String: From<T>, \
// <Implementor as Implementee>::Alias<T>: From<<Implementor as Implementee>::Alias<T>>"
pub use aux::Implementor;
17 changes: 17 additions & 0 deletions tests/rustdoc/inline_cross/auxiliary/assoc_item_trait_bounds.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -44,3 +44,20 @@ pub trait Helper {
pub trait Aid<'src> {
type Result<'inter: 'src>;
}

pub trait Implementee {
type Alias<T: Eq>
where
String: From<T>;
}

pub struct Implementor;

impl Implementee for Implementor {
type Alias<T: Eq> = T
where
String: From<T>,
// We will check that this bound doesn't get turned into an item bound since
// associated types in impls are not allowed to have any.
Self::Alias<T>: From<Self::Alias<T>>;
}

0 comments on commit 40e3fcf

Please sign in to comment.