rustdoc: Skip types in impls in search index

For a trait *implementation* there are typedefs which are the types for
that particular trait and implementor. Skip these in the search index.

There were lots of dud items in the search index due to this (search for
Item, Iterator's associated type).

Add a boolean to clean::TypedefItem so that it tracks whether the it is
a type alias on its own, or if it's a `type` item in a trait impl.

Fixes #22442

diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs
index 3ce8835b1a8de76744d561010ce4a5794d7e007e..c5c0f4dd8db1c7dfdbcda37198429d5537305285 100644 (file)
--- a/src/librustdoc/clean/inline.rs
+++ b/src/librustdoc/clean/inline.rs
@@ -216,7 +216,7 @@ fn build_type(cx: &DocContext, tcx: &ty::ctxt, did: ast::DefId) -> clean::ItemEn
     clean::TypedefItem(clean::Typedef {
         type_: t.ty.clean(cx),
         generics: (&t.generics, &predicates, subst::TypeSpace).clean(cx),
-    })
+    }, false)
 }
 
 pub fn build_impls(cx: &DocContext, tcx: &ty::ctxt,
@@ -368,7 +368,7 @@ pub fn build_impl(cx: &DocContext,
                                subst::ParamSpace::TypeSpace).clean(cx);
                 Some(clean::Item {
                     name: Some(assoc_ty.name.clean(cx)),
-                    inner: clean::TypedefItem(typedef),
+                    inner: clean::TypedefItem(typedef, true),
                     source: clean::Span::empty(),
                     attrs: vec![],
                     visibility: None,

diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 4c2357f8a8f0d05b1df64fbbe00cafe4997a53e0..d985fa4c8cc6c127618824c221878d0f2181f087 100644 (file)
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -343,7 +343,7 @@ pub enum ItemEnum {
     EnumItem(Enum),
     FunctionItem(Function),
     ModuleItem(Module),
-    TypedefItem(Typedef),
+    TypedefItem(Typedef, bool /* is associated type */),
     StaticItem(Static),
     ConstantItem(Constant),
     TraitItem(Trait),
@@ -1282,7 +1282,7 @@ fn clean(&self, cx: &DocContext) -> Item {
                     type_params: Vec::new(),
                     where_predicates: Vec::new()
                 },
-            }),
+            }, true),
             ast::MacImplItem(_) => {
                 MacroItem(Macro {
                     source: self.span.to_src(cx),
@@ -2078,7 +2078,7 @@ fn clean(&self, cx: &DocContext) -> Item {
             inner: TypedefItem(Typedef {
                 type_: self.ty.clean(cx),
                 generics: self.gen.clean(cx),
-            }),
+            }, false),
         }
     }
 }
@@ -2248,7 +2248,7 @@ fn build_deref_target_impls(cx: &DocContext,
 
     for item in items {
         let target = match item.inner {
-            TypedefItem(ref t) => &t.type_,
+            TypedefItem(ref t, true) => &t.type_,
             _ => continue,
         };
         let primitive = match *target {

diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs
index 36cf650d54e9af91d2c395d431ee9d2fab1f00fb..d82602c9bd0744f3cf9e532805b132107ab1487d 100644 (file)
--- a/src/librustdoc/html/render.rs
+++ b/src/librustdoc/html/render.rs
@@ -870,7 +870,7 @@ fn fold_item(&mut self, item: clean::Item) -> Option<clean::Item> {
             clean::StructItem(ref s)          => self.generics(&s.generics),
             clean::EnumItem(ref e)            => self.generics(&e.generics),
             clean::FunctionItem(ref f)        => self.generics(&f.generics),
-            clean::TypedefItem(ref t)         => self.generics(&t.generics),
+            clean::TypedefItem(ref t, _)      => self.generics(&t.generics),
             clean::TraitItem(ref t)           => self.generics(&t.generics),
             clean::ImplItem(ref i)            => self.generics(&i.generics),
             clean::TyMethodItem(ref i)        => self.generics(&i.generics),
@@ -936,6 +936,10 @@ fn fold_item(&mut self, item: clean::Item) -> Option<clean::Item> {
                         ((Some(*last), path), true)
                     }
                 }
+                clean::TypedefItem(_, true) => {
+                    // skip associated types in impls
+                    ((None, None), false)
+                }
                 _ => ((None, Some(&*self.stack)), false)
             };
             let hidden_field = match item.inner {
@@ -1497,7 +1501,7 @@ fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
             clean::TraitItem(ref t) => item_trait(fmt, self.cx, self.item, t),
             clean::StructItem(ref s) => item_struct(fmt, self.item, s),
             clean::EnumItem(ref e) => item_enum(fmt, self.item, e),
-            clean::TypedefItem(ref t) => item_typedef(fmt, self.item, t),
+            clean::TypedefItem(ref t, _) => item_typedef(fmt, self.item, t),
             clean::MacroItem(ref m) => item_macro(fmt, self.item, m),
             clean::PrimitiveItem(ref p) => item_primitive(fmt, self.item, p),
             clean::StaticItem(ref i) | clean::ForeignStaticItem(ref i) =>
@@ -2303,10 +2307,10 @@ fn render_deref_methods(w: &mut fmt::Formatter, impl_: &Impl) -> fmt::Result {
     let deref_type = impl_.impl_.trait_.as_ref().unwrap();
     let target = impl_.impl_.items.iter().filter_map(|item| {
         match item.inner {
-            clean::TypedefItem(ref t) => Some(&t.type_),
+            clean::TypedefItem(ref t, true) => Some(&t.type_),
             _ => None,
         }
-    }).next().unwrap();
+    }).next().expect("Expected associated type binding");
     let what = AssocItemRender::DerefFor { trait_: deref_type, type_: target };
     match *target {
         clean::ResolvedPath { did, .. } => render_assoc_items(w, did, what),
@@ -2350,7 +2354,7 @@ fn doctraititem(w: &mut fmt::Formatter, item: &clean::Item,
                 try!(render_assoc_item(w, item, link));
                 try!(write!(w, "</code></h4>\n"));
             }
-            clean::TypedefItem(ref tydef) => {
+            clean::TypedefItem(ref tydef, _) => {
                 let name = item.name.as_ref().unwrap();
                 try!(write!(w, "<h4 id='assoc_type.{}' class='{}'><code>",
                             *name,

diff --git a/src/test/rustdoc/search-index.rs b/src/test/rustdoc/search-index.rs
index 42469a21f22d0abbf25f3bfc31e5c76e396efde7..70b77f6760d8b24299a4ebdb8afcd3a05e538e7c 100644 (file)
--- a/src/test/rustdoc/search-index.rs
+++ b/src/test/rustdoc/search-index.rs
@@ -10,6 +10,8 @@
 
 #![crate_name = "rustdoc_test"]
 
+use std::ops::Deref;
+
 // @has search-index.js Foo
 pub use private::Foo;
 
@@ -24,3 +26,11 @@ pub trait PrivateTrait {
         fn trait_method(&self) {} // @!has - priv_method
     }
 }
+
+pub struct Bar;
+
+impl Deref for Bar {
+    // @!has search-index.js Target
+    type Target = Bar;
+    fn deref(&self) -> &Bar { self }
+}