rustdoc: Fix inlining type parameters

I'm not entirely sure if the correct space can be inferred when cleaning
Generics, so the impl has been switched to take the space explicitly.

Closes #15099

2 files changed, 12 insertions, 34 deletions

diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs
index 33e2fd2b893..e058f219c47 100644
--- a/src/librustdoc/clean/inline.rs
+++ b/src/librustdoc/clean/inline.rs
@@ -18,6 +18,7 @@ use rustc::metadata::csearch;
 use rustc::metadata::decoder;
 use rustc::middle::def;
 use rustc::middle::ty;
+use rustc::middle::subst;
 use rustc::middle::stability;
 
 use core;
@@ -163,7 +164,7 @@ pub fn build_external_trait(tcx: &ty::ctxt, did: ast::DefId) -> clean::Trait {
     });
 
     clean::Trait {
-        generics: def.generics.clean(),
+        generics: (&def.generics, subst::TypeSpace).clean(),
         methods: methods.collect(),
         parents: parents.collect()
     }
@@ -178,7 +179,7 @@ fn build_external_function(tcx: &ty::ctxt,
             ty::ty_bare_fn(ref f) => (did, &f.sig).clean(),
             _ => fail!("bad function"),
         },
-        generics: t.generics.clean(),
+        generics: (&t.generics, subst::FnSpace).clean(),
         fn_style: style,
     }
 }
@@ -196,7 +197,7 @@ fn build_struct(tcx: &ty::ctxt, did: ast::DefId) -> clean::Struct {
             [ref f, ..] if f.name == unnamed_field.name => doctree::Tuple,
             _ => doctree::Plain,
         },
-        generics: t.generics.clean(),
+        generics: (&t.generics, subst::TypeSpace).clean(),
         fields: fields.iter().map(|f| f.clean()).collect(),
         fields_stripped: false,
     }
@@ -207,7 +208,7 @@ fn build_type(tcx: &ty::ctxt, did: ast::DefId) -> clean::ItemEnum {
     match ty::get(t.ty).sty {
         ty::ty_enum(edid, _) if !csearch::is_typedef(&tcx.sess.cstore, did) => {
             return clean::EnumItem(clean::Enum {
-                generics: t.generics.clean(),
+                generics: (&t.generics, subst::TypeSpace).clean(),
                 variants_stripped: false,
                 variants: ty::enum_variants(tcx, edid).clean(),
             })
@@ -217,7 +218,7 @@ fn build_type(tcx: &ty::ctxt, did: ast::DefId) -> clean::ItemEnum {
 
     clean::TypedefItem(clean::Typedef {
         type_: t.ty.clean(),
-        generics: t.generics.clean(),
+        generics: (&t.generics, subst::TypeSpace).clean(),
     })
 }
 
@@ -323,7 +324,7 @@ fn build_impl(cx: &core::DocContext,
                 }
             }),
             for_: ty.ty.clean(),
-            generics: ty.generics.clean(),
+            generics: (&ty.generics, subst::TypeSpace).clean(),
             methods: methods,
         }),
         source: clean::Span::empty(),
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 57cda6c4817..05b91c5ddf9 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -653,35 +653,12 @@ impl Clean<Generics> for ast::Generics {
     }
 }
 
-impl Clean<Generics> for ty::Generics {
+impl<'a> Clean<Generics> for (&'a ty::Generics, subst::ParamSpace) {
     fn clean(&self) -> Generics {
-        // In the type space, generics can come in one of multiple
-        // namespaces.  This means that e.g. for fn items the type
-        // parameters will live in FnSpace, but for types the
-        // parameters will live in TypeSpace (trait definitions also
-        // define a parameter in SelfSpace). *Method* definitions are
-        // the one exception: they combine the TypeSpace parameters
-        // from the enclosing impl/trait with their own FnSpace
-        // parameters.
-        //
-        // In general, when we clean, we are trying to produce the
-        // "user-facing" generics. Hence we select the most specific
-        // namespace that is occupied, ignoring SelfSpace because it
-        // is implicit.
-
-        let space = {
-            if !self.types.is_empty_in(subst::FnSpace) ||
-                !self.regions.is_empty_in(subst::FnSpace)
-            {
-                subst::FnSpace
-            } else {
-                subst::TypeSpace
-            }
-        };
-
+        let (me, space) = *self;
         Generics {
-            type_params: Vec::from_slice(self.types.get_slice(space)).clean(),
-            lifetimes: Vec::from_slice(self.regions.get_slice(space)).clean(),
+            type_params: Vec::from_slice(me.types.get_slice(space)).clean(),
+            lifetimes: Vec::from_slice(me.regions.get_slice(space)).clean(),
         }
     }
 }
@@ -1030,7 +1007,7 @@ impl Clean<Item> for ty::Method {
             source: Span::empty(),
             inner: TyMethodItem(TyMethod {
                 fn_style: self.fty.fn_style,
-                generics: self.generics.clean(),
+                generics: (&self.generics, subst::FnSpace).clean(),
                 self_: self_,
                 decl: (self.def_id, &sig).clean(),
             })