impl Clean<Generics> for hir::Generics {
fn clean(&self, cx: &DocContext) -> Generics {
+ let mut params = Vec::with_capacity(self.params.len());
+ for p in &self.params {
+ let p = p.clean(cx);
+ if let GenericParam::Type(ref tp) = p {
+ if tp.synthetic == Some(hir::SyntheticTyParamKind::ImplTrait) {
+ cx.impl_trait_bounds.borrow_mut().insert(tp.did, tp.bounds.clone());
+ }
+ }
+ params.push(p);
+ }
let mut g = Generics {
- params: self.params.clean(cx),
+ params,
where_predicates: self.where_clause.predicates.clean(cx)
};
impl<'a> Clean<Method> for (&'a hir::MethodSig, &'a hir::Generics, hir::BodyId) {
fn clean(&self, cx: &DocContext) -> Method {
- let generics = self.1.clean(cx);
+ let (generics, decl) = enter_impl_trait(cx, || {
+ (self.1.clean(cx), (&*self.0.decl, self.2).clean(cx))
+ });
Method {
- decl: enter_impl_trait(cx, &generics.params, || (&*self.0.decl, self.2).clean(cx)),
+ decl,
generics,
unsafety: self.0.unsafety,
constness: self.0.constness,
impl Clean<Item> for doctree::Function {
fn clean(&self, cx: &DocContext) -> Item {
- let generics = self.generics.clean(cx);
- let decl = enter_impl_trait(cx, &generics.params, || (&self.decl, self.body).clean(cx));
+ let (generics, decl) = enter_impl_trait(cx, || {
+ (self.generics.clean(cx), (&self.decl, self.body).clean(cx))
+ });
Item {
name: Some(self.name.clean(cx)),
attrs: self.attrs.clean(cx),
MethodItem((sig, &self.generics, body).clean(cx))
}
hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Required(ref names)) => {
- let generics = self.generics.clean(cx);
+ let (generics, decl) = enter_impl_trait(cx, || {
+ (self.generics.clean(cx), (&*sig.decl, &names[..]).clean(cx))
+ });
TyMethodItem(TyMethod {
unsafety: sig.unsafety.clone(),
- decl: enter_impl_trait(cx, &generics.params, || {
- (&*sig.decl, &names[..]).clean(cx)
- }),
+ decl,
generics,
abi: sig.abi
})
impl Clean<BareFunctionDecl> for hir::BareFnTy {
fn clean(&self, cx: &DocContext) -> BareFunctionDecl {
- let generic_params = self.generic_params.clean(cx);
+ let (generic_params, decl) = enter_impl_trait(cx, || {
+ (self.generic_params.clean(cx), (&*self.decl, &self.arg_names[..]).clean(cx))
+ });
BareFunctionDecl {
unsafety: self.unsafety,
- decl: enter_impl_trait(cx, &generic_params, || {
- (&*self.decl, &self.arg_names[..]).clean(cx)
- }),
+ decl,
generic_params,
abi: self.abi,
}
fn clean(&self, cx: &DocContext) -> Item {
let inner = match self.node {
hir::ForeignItemFn(ref decl, ref names, ref generics) => {
- let generics = generics.clean(cx);
+ let (generics, decl) = enter_impl_trait(cx, || {
+ (generics.clean(cx), (&**decl, &names[..]).clean(cx))
+ });
ForeignFunctionItem(Function {
- decl: enter_impl_trait(cx, &generics.params, || {
- (&**decl, &names[..]).clean(cx)
- }),
+ decl,
generics,
unsafety: hir::Unsafety::Unsafe,
abi: Abi::Rust,
once(crate_name).chain(relative).collect()
}
-pub fn enter_impl_trait<F, R>(cx: &DocContext, gps: &[GenericParam], f: F) -> R
+pub fn enter_impl_trait<F, R>(cx: &DocContext, f: F) -> R
where
F: FnOnce() -> R,
{
- let bounds = gps.iter()
- .filter_map(|p| {
- if let GenericParam::Type(ref tp) = *p {
- if tp.synthetic == Some(hir::SyntheticTyParamKind::ImplTrait) {
- return Some((tp.did, tp.bounds.clone()));
- }
- }
-
- None
- })
- .collect::<FxHashMap<DefId, Vec<TyParamBound>>>();
-
- let old_bounds = mem::replace(&mut *cx.impl_trait_bounds.borrow_mut(), bounds);
+ let old_bounds = mem::replace(&mut *cx.impl_trait_bounds.borrow_mut(), Default::default());
let r = f();
assert!(cx.impl_trait_bounds.borrow().is_empty());
*cx.impl_trait_bounds.borrow_mut() = old_bounds;