Fix #24575

Author: aochagavia

src/librustdoc/html/render.rs

@@ -51,25 +51,19 @@ use std::sync::Arc;
 
 use externalfiles::ExternalHtml;
 
-use serialize::json;
-use serialize::json::ToJson;
-use syntax::abi;
-use syntax::ast;
-use syntax::ast_util;
-use syntax::attr;
+use serialize::json::{self, ToJson};
+use syntax::{abi, ast, ast_util, attr};
 use rustc::util::nodemap::NodeSet;
 
-use clean;
+use clean::{self, SelfTy};
 use doctree;
 use fold::DocFolder;
 use html::escape::Escape;
 use html::format::{TyParamBounds, WhereClause, href, AbiSpace};
 use html::format::{VisSpace, Method, UnsafetySpace, MutableSpace};
-use html::highlight;
 use html::item_type::ItemType;
-use html::layout;
-use html::markdown::Markdown;
-use html::markdown;
+use html::markdown::{self, Markdown};
+use html::{highlight, layout};
 
 /// A pair of name and its optional document.
 pub type NameDoc = (String, Option<String>);
@@ -2281,6 +2275,9 @@ fn render_deref_methods(w: &mut fmt::Formatter, impl_: &Impl) -> fmt::Result {
     }
 }
 
+// Render_header is false when we are rendering a `Deref` impl and true
+// otherwise. If render_header is false, we will avoid rendering static
+// methods, since they are not accessible for the type implementing `Deref`
 fn render_impl(w: &mut fmt::Formatter, i: &Impl, link: MethodLink,
                render_header: bool) -> fmt::Result {
     if render_header {
@@ -2300,14 +2297,17 @@ fn render_impl(w: &mut fmt::Formatter, i: &Impl, link: MethodLink,
     }
 
     fn doctraititem(w: &mut fmt::Formatter, item: &clean::Item,
-                    link: MethodLink) -> fmt::Result {
+                    link: MethodLink, render_static: bool) -> fmt::Result {
         match item.inner {
             clean::MethodItem(..) | clean::TyMethodItem(..) => {
-                try!(write!(w, "<h4 id='method.{}' class='{}'><code>",
-                            *item.name.as_ref().unwrap(),
-                            shortty(item)));
-                try!(render_method(w, item, link));
-                try!(write!(w, "</code></h4>\n"));
+                // Only render when the method is not static or we allow static methods
+                if !is_static_method(item) || render_static {
+                    try!(write!(w, "<h4 id='method.{}' class='{}'><code>",
+                                *item.name.as_ref().unwrap(),
+                                shortty(item)));
+                    try!(render_method(w, item, link));
+                    try!(write!(w, "</code></h4>\n"));
+                }
             }
             clean::TypedefItem(ref tydef) => {
                 let name = item.name.as_ref().unwrap();
@@ -2327,30 +2327,44 @@ fn render_impl(w: &mut fmt::Formatter, i: &Impl, link: MethodLink,
             }
             _ => panic!("can't make docs for trait item with name {:?}", item.name)
         }
-        if let MethodLink::Anchor = link {
-            document(w, item)
+
+        return if let MethodLink::Anchor = link {
+            if is_static_method(item) && !render_static {
+                Ok(())
+            } else {
+                document(w, item)
+            }
         } else {
             Ok(())
+        };
+
+        fn is_static_method(item: &clean::Item) -> bool {
+            match item.inner {
+                clean::MethodItem(ref method) => method.self_ == SelfTy::SelfStatic,
+                clean::TyMethodItem(ref method) => method.self_ == SelfTy::SelfStatic,
+                _ => false
+            }
         }
     }
 
     try!(write!(w, "<div class='impl-items'>"));
     for trait_item in i.impl_.items.iter() {
-        try!(doctraititem(w, trait_item, link));
+        try!(doctraititem(w, trait_item, link, render_header));
     }
 
     fn render_default_methods(w: &mut fmt::Formatter,
                               did: ast::DefId,
                               t: &clean::Trait,
-                              i: &clean::Impl) -> fmt::Result {
+                              i: &clean::Impl,
+                              render_static: bool) -> fmt::Result {
         for trait_item in &t.items {
             let n = trait_item.name.clone();
             match i.items.iter().find(|m| { m.name == n }) {
                 Some(..) => continue,
                 None => {}
             }
 
-            try!(doctraititem(w, trait_item, MethodLink::GotoSource(did)));
+            try!(doctraititem(w, trait_item, MethodLink::GotoSource(did), render_static));
         }
         Ok(())
     }
@@ -2361,7 +2375,7 @@ fn render_impl(w: &mut fmt::Formatter, i: &Impl, link: MethodLink,
     // for them work.
     if let Some(clean::ResolvedPath { did, .. }) = i.impl_.trait_ {
         if let Some(t) = cache().traits.get(&did) {
-            try!(render_default_methods(w, did, t, &i.impl_));
+            try!(render_default_methods(w, did, t, &i.impl_, render_header));
         }
     }
     try!(write!(w, "</div>"));