From 52a3d38796c616bbed39cda2dc3538f2cedbd5ac Mon Sep 17 00:00:00 2001
From: Kevin Ballard <kevin@sb.org>
Date: Tue, 11 Feb 2014 14:29:23 -0800
Subject: [PATCH 1/2] rustdoc: Strip impls of stripped private types

In strip-private, also strip impls of traits for private types. This
fixes the search index so searching for "drop", "eq", etc doesn't throw
an exception.
---
 src/librustdoc/passes.rs | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/src/librustdoc/passes.rs b/src/librustdoc/passes.rs
index 30643737078e8..fce4cab52c937 100644
--- a/src/librustdoc/passes.rs
+++ b/src/librustdoc/passes.rs
@@ -110,8 +110,16 @@ impl<'a> fold::DocFolder for Stripper<'a> {
             // handled below
             clean::ModuleItem(..) => {}
 
-            // impls/tymethods have no control over privacy
-            clean::ImplItem(..) | clean::TyMethodItem(..) => {}
+            // trait impls for private items should be stripped
+            clean::ImplItem(clean::Impl{ for_: clean::ResolvedPath{ id: ref for_id, .. }, .. }) => {
+                if !self.exported_items.contains(for_id) {
+                    return None;
+                }
+            }
+            clean::ImplItem(..) => {}
+
+            // tymethods have no control over privacy
+            clean::TyMethodItem(..) => {}
         }
 
         let fastreturn = match i.inner {

From 9e6c3f03bc09873eae0c9d1eae9b7a3603fb4f6c Mon Sep 17 00:00:00 2001
From: Kevin Ballard <kevin@sb.org>
Date: Tue, 11 Feb 2014 14:42:23 -0800
Subject: [PATCH 2/2] rustdoc: Strip impls of traits on #[doc(hidden)] types

In the strip-hidden pass, record all types that were stripped, and make
a second pass stripping all impls of traits for these types.
---
 src/librustdoc/passes.rs | 70 +++++++++++++++++++++++++++++-----------
 1 file changed, 51 insertions(+), 19 deletions(-)

diff --git a/src/librustdoc/passes.rs b/src/librustdoc/passes.rs
index fce4cab52c937..6ebaf6eece82d 100644
--- a/src/librustdoc/passes.rs
+++ b/src/librustdoc/passes.rs
@@ -22,30 +22,62 @@ use fold::DocFolder;
 
 /// Strip items marked `#[doc(hidden)]`
 pub fn strip_hidden(krate: clean::Crate) -> plugins::PluginResult {
-    struct Stripper;
-    impl fold::DocFolder for Stripper {
-        fn fold_item(&mut self, i: Item) -> Option<Item> {
-            for attr in i.attrs.iter() {
-                match attr {
-                    &clean::List(~"doc", ref l) => {
-                        for innerattr in l.iter() {
-                            match innerattr {
-                                &clean::Word(ref s) if "hidden" == *s => {
-                                    debug!("found one in strip_hidden; removing");
-                                    return None;
-                                },
-                                _ => (),
+    let mut stripped = HashSet::new();
+
+    // strip all #[doc(hidden)] items
+    let krate = {
+        struct Stripper<'a> {
+            stripped: &'a mut HashSet<ast::NodeId>
+        };
+        impl<'a> fold::DocFolder for Stripper<'a> {
+            fn fold_item(&mut self, i: Item) -> Option<Item> {
+                for attr in i.attrs.iter() {
+                    match attr {
+                        &clean::List(~"doc", ref l) => {
+                            for innerattr in l.iter() {
+                                match innerattr {
+                                    &clean::Word(ref s) if "hidden" == *s => {
+                                        debug!("found one in strip_hidden; removing");
+                                        self.stripped.insert(i.id);
+                                        return None;
+                                    },
+                                    _ => (),
+                                }
                             }
+                        },
+                        _ => ()
+                    }
+                }
+                self.fold_item_recur(i)
+            }
+        }
+        let mut stripper = Stripper{ stripped: &mut stripped };
+        stripper.fold_crate(krate)
+    };
+
+    // strip any traits implemented on stripped items
+    let krate = {
+        struct ImplStripper<'a> {
+            stripped: &'a mut HashSet<ast::NodeId>
+        };
+        impl<'a> fold::DocFolder for ImplStripper<'a> {
+            fn fold_item(&mut self, i: Item) -> Option<Item> {
+                match i.inner {
+                    clean::ImplItem(clean::Impl{ for_: clean::ResolvedPath{ id: for_id, .. },
+                                                 .. }) => {
+                        if self.stripped.contains(&for_id) {
+                            return None;
                         }
-                    },
-                    _ => ()
+                    }
+                    _ => {}
                 }
+                self.fold_item_recur(i)
             }
-            self.fold_item_recur(i)
         }
-    }
-    let mut stripper = Stripper;
-    let krate = stripper.fold_crate(krate);
+        let mut stripper = ImplStripper{ stripped: &mut stripped };
+        stripper.fold_crate(krate)
+    };
+
     (krate, None)
 }