diff options
| -rw-r--r-- | src/librustdoc/clean/inline.rs | 45 | ||||
| -rw-r--r-- | src/librustdoc/clean/mod.rs | 220 | ||||
| -rw-r--r-- | src/librustdoc/fold.rs | 39 | ||||
| -rw-r--r-- | src/librustdoc/html/render.rs | 430 | ||||
| -rw-r--r-- | src/librustdoc/lib.rs | 94 | ||||
| -rw-r--r-- | src/librustdoc/passes.rs | 43 | ||||
| -rw-r--r-- | src/librustdoc/test.rs | 21 | ||||
| -rw-r--r-- | src/librustdoc/visit_ast.rs | 6 |
8 files changed, 356 insertions, 542 deletions
diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs index 02ea83615a3..32f3706675a 100644 --- a/src/librustdoc/clean/inline.rs +++ b/src/librustdoc/clean/inline.rs @@ -26,7 +26,7 @@ use rustc::middle::const_eval; use core::DocContext; use doctree; -use clean; +use clean::{self, Attributes}; use super::{Clean, ToSource}; @@ -138,13 +138,10 @@ pub fn load_attrs(cx: &DocContext, tcx: &TyCtxt, /// These names are used later on by HTML rendering to generate things like /// source links back to the original item. pub fn record_extern_fqn(cx: &DocContext, did: DefId, kind: clean::TypeKind) { - match cx.tcx_opt() { - Some(tcx) => { - let fqn = tcx.sess.cstore.extern_item_path(did); - let fqn = fqn.into_iter().map(|i| i.to_string()).collect(); - cx.external_paths.borrow_mut().as_mut().unwrap().insert(did, (fqn, kind)); - } - None => {} + if let Some(tcx) = cx.tcx_opt() { + let fqn = tcx.sess.cstore.extern_item_path(did); + let fqn = fqn.into_iter().map(|i| i.to_string()).collect(); + cx.external_paths.borrow_mut().as_mut().unwrap().insert(did, (fqn, kind)); } } @@ -230,12 +227,9 @@ pub fn build_impls(cx: &DocContext, tcx: &TyCtxt, tcx.populate_inherent_implementations_for_type_if_necessary(did); let mut impls = Vec::new(); - match tcx.inherent_impls.borrow().get(&did) { - None => {} - Some(i) => { - for &did in i.iter() { - build_impl(cx, tcx, did, &mut impls); - } + if let Some(i) = tcx.inherent_impls.borrow().get(&did) { + for &did in i.iter() { + build_impl(cx, tcx, did, &mut impls); } } @@ -259,7 +253,7 @@ pub fn build_impls(cx: &DocContext, tcx: &TyCtxt, cstore::DlImpl(did) => build_impl(cx, tcx, did, impls), cstore::DlDef(Def::Mod(did)) => { // Don't recurse if this is a #[doc(hidden)] module - if load_attrs(cx, tcx, did).iter().any(|a| is_doc_hidden(a)) { + if load_attrs(cx, tcx, did).list_def("doc").has_word("hidden") { return; } @@ -288,7 +282,7 @@ pub fn build_impl(cx: &DocContext, if let Some(ref t) = associated_trait { // If this is an impl for a #[doc(hidden)] trait, be sure to not inline let trait_attrs = load_attrs(cx, tcx, t.def_id); - if trait_attrs.iter().any(|a| is_doc_hidden(a)) { + if trait_attrs.list_def("doc").has_word("hidden") { return } } @@ -428,20 +422,6 @@ pub fn build_impl(cx: &DocContext, }); } -fn is_doc_hidden(a: &clean::Attribute) -> bool { - match *a { - clean::List(ref name, ref inner) if *name == "doc" => { - inner.iter().any(|a| { - match *a { - clean::Word(ref s) => *s == "hidden", - _ => false, - } - }) - } - _ => false - } -} - fn build_module(cx: &DocContext, tcx: &TyCtxt, did: DefId) -> clean::Module { let mut items = Vec::new(); @@ -464,9 +444,8 @@ fn build_module(cx: &DocContext, tcx: &TyCtxt, } cstore::DlDef(def) if item.vis == hir::Public => { if !visited.insert(def) { continue } - match try_inline_def(cx, tcx, def) { - Some(i) => items.extend(i), - None => {} + if let Some(i) = try_inline_def(cx, tcx, def) { + items.extend(i) } } cstore::DlDef(..) => {} diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index b6da5b0ef20..6c9ee528782 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -100,10 +100,7 @@ impl<T: Clean<U>, U> Clean<U> for Rc<T> { impl<T: Clean<U>, U> Clean<Option<U>> for Option<T> { fn clean(&self, cx: &DocContext) -> Option<U> { - match self { - &None => None, - &Some(ref v) => Some(v.clean(cx)) - } + self.as_ref().map(|v| v.clean(cx)) } } @@ -178,9 +175,8 @@ impl<'a, 'tcx> Clean<Crate> for visit_ast::RustdocVisitor<'a, 'tcx> { }; let mut tmp = Vec::new(); for child in &mut m.items { - match child.inner { - ModuleItem(..) => {} - _ => continue, + if !child.is_mod() { + continue; } let prim = match PrimitiveType::find(&child.attrs) { Some(prim) => prim, @@ -261,7 +257,7 @@ pub struct Item { pub source: Span, /// Not everything has a name. E.g., impls pub name: Option<String>, - pub attrs: Vec<Attribute> , + pub attrs: Vec<Attribute>, pub inner: ItemEnum, pub visibility: Option<Visibility>, pub def_id: DefId, @@ -270,51 +266,17 @@ pub struct Item { } impl Item { - /// Finds the `doc` attribute as a List and returns the list of attributes - /// nested inside. - pub fn doc_list<'a>(&'a self) -> Option<&'a [Attribute]> { - for attr in &self.attrs { - match *attr { - List(ref x, ref list) if "doc" == *x => { - return Some(list); - } - _ => {} - } - } - return None; - } - /// Finds the `doc` attribute as a NameValue and returns the corresponding /// value found. pub fn doc_value<'a>(&'a self) -> Option<&'a str> { - for attr in &self.attrs { - match *attr { - NameValue(ref x, ref v) if "doc" == *x => { - return Some(v); - } - _ => {} - } - } - return None; + self.attrs.value("doc") } - - pub fn is_hidden_from_doc(&self) -> bool { - match self.doc_list() { - Some(l) => { - for innerattr in l { - match *innerattr { - Word(ref s) if "hidden" == *s => { - return true - } - _ => (), - } - } - }, - None => () + pub fn is_crate(&self) -> bool { + match self.inner { + ModuleItem(Module { items: _, is_crate: true }) => true, + _ => false } - return false; } - pub fn is_mod(&self) -> bool { match self.inner { ModuleItem(..) => true, _ => false } } @@ -330,29 +292,34 @@ impl Item { pub fn is_fn(&self) -> bool { match self.inner { FunctionItem(..) => true, _ => false } } + pub fn is_associated_type(&self) -> bool { + match self.inner { AssociatedTypeItem(..) => true, _ => false } + } + pub fn is_associated_const(&self) -> bool { + match self.inner { AssociatedConstItem(..) => true, _ => false } + } + pub fn is_method(&self) -> bool { + match self.inner { MethodItem(..) => true, _ => false } + } + pub fn is_ty_method(&self) -> bool { + match self.inner { TyMethodItem(..) => true, _ => false } + } pub fn stability_class(&self) -> String { - match self.stability { - Some(ref s) => { - let mut base = match s.level { - stability::Unstable => "unstable".to_string(), - stability::Stable => String::new(), - }; - if !s.deprecated_since.is_empty() { - base.push_str(" deprecated"); - } - base + self.stability.as_ref().map(|ref s| { + let mut base = match s.level { + stability::Unstable => "unstable".to_string(), + stability::Stable => String::new(), + }; + if !s.deprecated_since.is_empty() { + base.push_str(" deprecated"); } - _ => String::new(), - } + base + }).unwrap_or(String::new()) } pub fn stable_since(&self) -> Option<&str> { - if let Some(ref s) = self.stability { - return Some(&s.since[..]); - } - - None + self.stability.as_ref().map(|s| &s.since[..]) } } @@ -448,10 +415,54 @@ impl Clean<Item> for doctree::Module { } } +pub trait Attributes { + fn has_word(&self, &str) -> bool; + fn value<'a>(&'a self, &str) -> Option<&'a str>; + fn list_def<'a>(&'a self, &str) -> &'a [Attribute]; +} + +impl Attributes for [Attribute] { + /// Returns whether the attribute list contains a specific `Word` + fn has_word(&self, word: &str) -> bool { + for attr in self { + if let Word(ref w) = *attr { + if word == *w { + return true; + } + } + } + false + } + + /// Finds an attribute as NameValue and returns the corresponding value found. + fn value<'a>(&'a self, name: &str) -> Option<&'a str> { + for attr in self { + if let NameValue(ref x, ref v) = *attr { + if name == *x { + return Some(v); + } + } + } + None + } + + /// Finds an attribute as List and returns the list of attributes nested inside. + fn list_def<'a>(&'a self, name: &str) -> &'a [Attribute] { + for attr in self { + if let List(ref x, ref list) = *attr { + if name == *x { + return &list[..]; + } + } + } + &[] + } +} + #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Debug)] pub enum Attribute { Word(String), - List(String, Vec<Attribute> ), + List(String, Vec<Attribute>), NameValue(String, String) } @@ -496,12 +507,6 @@ impl attr::AttrMetaMethods for Attribute { fn meta_item_list<'a>(&'a self) -> Option<&'a [P<ast::MetaItem>]> { None } fn span(&self) -> codemap::Span { unimplemented!() } } -impl<'a> attr::AttrMetaMethods for &'a Attribute { - fn name(&self) -> InternedString { (**self).name() } - fn value_str(&self) -> Option<InternedString> { (**self).value_str() } - fn meta_item_list(&self) -> Option<&[P<ast::MetaItem>]> { None } - fn span(&self) -> codemap::Span { unimplemented!() } -} #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Debug)] pub struct TyParam { @@ -711,7 +716,7 @@ impl<'tcx> Clean<TyParamBound> for ty::TraitRef<'tcx> { if let &ty::Region::ReLateBound(_, _) = *reg { debug!(" hit an ReLateBound {:?}", reg); if let Some(lt) = reg.clean(cx) { - late_bounds.push(lt) + late_bounds.push(lt); } } } @@ -780,8 +785,7 @@ impl Clean<Option<Lifetime>> for ty::Region { fn clean(&self, cx: &DocContext) -> Option<Lifetime> { match *self { ty::ReStatic => Some(Lifetime::statik()), - ty::ReLateBound(_, ty::BrNamed(_, name)) => - Some(Lifetime(name.to_string())), + ty::ReLateBound(_, ty::BrNamed(_, name)) => Some(Lifetime(name.to_string())), ty::ReEarlyBound(ref data) => Some(Lifetime(data.name.clean(cx))), ty::ReLateBound(..) | @@ -1151,12 +1155,12 @@ impl<'tcx> Clean<Type> for ty::FnOutput<'tcx> { impl<'a, 'tcx> Clean<FnDecl> for (DefId, &'a ty::PolyFnSig<'tcx>) { fn clean(&self, cx: &DocContext) -> FnDecl { let (did, sig) = *self; - let mut names = if let Some(_) = cx.map.as_local_node_id(did) { + let mut names = if cx.map.as_local_node_id(did).is_some() { vec![].into_iter() } else { cx.tcx().sess.cstore.method_arg_names(did).into_iter() }.peekable(); - if names.peek().map(|s| &**s) == Some("self") { + if let Some("self") = names.peek().map(|s| &s[..]) { let _ = names.next(); } FnDecl { @@ -1524,24 +1528,16 @@ impl PrimitiveType { } fn find(attrs: &[Attribute]) -> Option<PrimitiveType> { - for attr in attrs { - let list = match *attr { - List(ref k, ref l) if *k == "doc" => l, - _ => continue, - }; - for sub_attr in list { - let value = match *sub_attr { - NameValue(ref k, ref v) - if *k == "primitive" => v, - _ => continue, - }; - match PrimitiveType::from_str(value) { - Some(p) => return Some(p), - None => {} + for attr in attrs.list_def("doc") { + if let NameValue(ref k, ref v) = *attr { + if "primitive" == *k { + if let ret@Some(..) = PrimitiveType::from_str(v) { + return ret; + } } } } - return None + None } pub fn to_string(&self) -> &'static str { @@ -1627,15 +1623,9 @@ impl Clean<Type> for hir::Ty { } } TyBareFn(ref barefn) => BareFunction(box barefn.clean(cx)), - TyPolyTraitRef(ref bounds) => { - PolyTraitRef(bounds.clean(cx)) - }, - TyInfer => { - Infer - }, - TyTypeof(..) => { - panic!("Unimplemented type {:?}", self.node) - }, + TyPolyTraitRef(ref bounds) => PolyTraitRef(bounds.clean(cx)), + TyInfer => Infer, + TyTypeof(..) => panic!("Unimplemented type {:?}", self.node), } } } @@ -2253,7 +2243,7 @@ impl Clean<Vec<Item>> for doctree::Impl { polarity: Some(self.polarity.clean(cx)), }), }); - return ret; + ret } } @@ -2393,9 +2383,8 @@ impl Clean<Vec<Item>> for doctree::Import { } hir::ViewPathSimple(name, ref p) => { if !denied { - match inline::try_inline(cx, self.id, Some(name)) { - Some(items) => return items, - None => {} + if let Some(items) = inline::try_inline(cx, self.id, Some(name)) { + return items; } } (vec![], SimpleImport(name.clean(cx), @@ -2460,9 +2449,8 @@ impl Clean<Vec<Item>> for hir::ForeignMod { fn clean(&self, cx: &DocContext) -> Vec<Item> { let mut items = self.items.clean(cx); for item in &mut items { - match item.inner { - ForeignFunctionItem(ref mut f) => f.abi = self.abi, - _ => {} + if let ForeignFunctionItem(ref mut f) = item.inner { + f.abi = self.abi; } } items @@ -2598,11 +2586,7 @@ fn resolve_type(cx: &DocContext, }; } }; - let def = match tcx.def_map.borrow().get(&id) { - Some(k) => k.full_def(), - None => panic!("unresolved id not in defmap") - }; - + let def = tcx.def_map.borrow().get(&id).expect("unresolved id not in defmap").full_def(); debug!("resolve_type: def={:?}", def); let is_generic = match def { @@ -2659,7 +2643,7 @@ fn register_def(cx: &DocContext, def: Def) -> DefId { let t = inline::build_external_trait(cx, tcx, did); cx.external_traits.borrow_mut().as_mut().unwrap().insert(did, t); } - return did; + did } fn resolve_use_source(cx: &DocContext, path: Path, id: ast::NodeId) -> ImportSource { @@ -2732,12 +2716,10 @@ impl Clean<Stability> for attr::Stability { _=> "".to_string(), }, reason: { - if let Some(ref depr) = self.rustc_depr { - depr.reason.to_string() - } else if let attr::Unstable {reason: Some(ref reason), ..} = self.level { - reason.to_string() - } else { - "".to_string() + match (&self.rustc_depr, &self.level) { + (&Some(ref depr), _) => depr.reason.to_string(), + (&None, &attr::Unstable {reason: Some(ref reason), ..}) => reason.to_string(), + _ => "".to_string(), } }, issue: match self.level { diff --git a/src/librustdoc/fold.rs b/src/librustdoc/fold.rs index 5a4f95d1a1a..ceec80402c0 100644 --- a/src/librustdoc/fold.rs +++ b/src/librustdoc/fold.rs @@ -9,8 +9,6 @@ // except according to those terms. use clean::*; -use std::collections::HashMap; -use std::mem::{replace, swap}; pub trait DocFolder : Sized { fn fold_item(&mut self, item: Item) -> Option<Item> { @@ -20,12 +18,10 @@ pub trait DocFolder : Sized { /// don't override! fn fold_item_recur(&mut self, item: Item) -> Option<Item> { let Item { attrs, name, source, visibility, def_id, inner, stability, deprecation } = item; - let inner = inner; let inner = match inner { StructItem(mut i) => { - let mut foo = Vec::new(); swap(&mut foo, &mut i.fields); - let num_fields = foo.len(); - i.fields.extend(foo.into_iter().filter_map(|x| self.fold_item(x))); + let num_fields = i.fields.len(); + i.fields = i.fields.into_iter().filter_map(|x| self.fold_item(x)).collect(); i.fields_stripped |= num_fields != i.fields.len(); StructItem(i) }, @@ -33,29 +29,25 @@ pub trait DocFolder : Sized { ModuleItem(self.fold_mod(i)) }, EnumItem(mut i) => { - let mut foo = Vec::new(); swap(&mut foo, &mut i.variants); - let num_variants = foo.len(); - i.variants.extend(foo.into_iter().filter_map(|x| self.fold_item(x))); + let num_variants = i.variants.len(); + i.variants = i.variants.into_iter().filter_map(|x| self.fold_item(x)).collect(); i.variants_stripped |= num_variants != i.variants.len(); EnumItem(i) }, TraitItem(mut i) => { - let mut foo = Vec::new(); swap(&mut foo, &mut i.items); - i.items.extend(foo.into_iter().filter_map(|x| self.fold_item(x))); + i.items = i.items.into_iter().filter_map(|x| self.fold_item(x)).collect(); TraitItem(i) }, ImplItem(mut i) => { - let mut foo = Vec::new(); swap(&mut foo, &mut i.items); - i.items.extend(foo.into_iter().filter_map(|x| self.fold_item(x))); + i.items = i.items.into_iter().filter_map(|x| self.fold_item(x)).collect(); ImplItem(i) }, VariantItem(i) => { let i2 = i.clone(); // this clone is small match i.kind { StructVariant(mut j) => { - let mut foo = Vec::new(); swap(&mut foo, &mut j.fields); - let num_fields = foo.len(); - j.fields.extend(foo.into_iter().filter_map(|x| self.fold_item(x))); + let num_fields = j.fields.len(); + j.fields = j.fields.into_iter().filter_map(|x| self.fold_item(x)).collect(); j.fields_stripped |= num_fields != j.fields.len(); VariantItem(Variant {kind: StructVariant(j), ..i2}) }, @@ -78,16 +70,13 @@ pub trait DocFolder : Sized { } fn fold_crate(&mut self, mut c: Crate) -> Crate { - c.module = match replace(&mut c.module, None) { - Some(module) => self.fold_item(module), None => None - }; - let external_traits = replace(&mut c.external_traits, HashMap::new()); - c.external_traits = external_traits.into_iter().map(|(k, mut v)| { - let items = replace(&mut v.items, Vec::new()); - v.items = items.into_iter().filter_map(|i| self.fold_item(i)) - .collect(); + c.module = c.module.and_then(|module| { + self.fold_item(module) + }); + c.external_traits = c.external_traits.into_iter().map(|(k, mut v)| { + v.items = v.items.into_iter().filter_map(|i| self.fold_item(i)).collect(); (k, v) }).collect(); - return c; + c } } diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index af6dec8dc86..2cb2b299e40 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -62,7 +62,7 @@ use rustc::middle::stability; use rustc::session::config::get_unstable_features_setting; use rustc_front::hir; -use clean::{self, SelfTy}; +use clean::{self, SelfTy, Attributes}; use doctree; use fold::DocFolder; use html::escape::Escape; @@ -104,6 +104,8 @@ pub struct Context { /// the source files are present in the html rendering, then this will be /// `true`. pub include_sources: bool, + /// The local file sources we've emitted and their respective url-paths. + pub local_sources: HashMap<PathBuf, String>, /// A flag, which when turned off, will render pages which redirect to the /// real location of an item. This is used to allow external links to /// publicly reused items to redirect to the right location. @@ -262,8 +264,6 @@ pub struct Cache { struct SourceCollector<'a> { cx: &'a mut Context, - /// Processed source-file paths - seen: HashSet<String>, /// Root destination to place all HTML output into dst: PathBuf, } @@ -374,7 +374,7 @@ fn init_ids() -> HashMap<String, usize> { "deref-methods", "implementations", "derived_implementations" - ].into_iter().map(|id| (String::from(*id), 1)).collect::<HashMap<_, _>>() + ].into_iter().map(|id| (String::from(*id), 1)).collect() } /// This method resets the local table of used ID attributes. This is typically @@ -423,6 +423,7 @@ pub fn run(mut krate: clean::Crate, playground_url: "".to_string(), }, include_sources: true, + local_sources: HashMap::new(), render_redirect_pages: false, issue_tracker_base_url: None, }; @@ -431,42 +432,38 @@ pub fn run(mut krate: clean::Crate, // Crawl the crate attributes looking for attributes which control how we're // going to emit HTML - let default: &[_] = &[]; - match krate.module.as_ref().map(|m| m.doc_list().unwrap_or(default)) { - Some(attrs) => { - for attr in attrs { - match *attr { - clean::NameValue(ref x, ref s) - if "html_favicon_url" == *x => { - cx.layout.favicon = s.to_string(); - } - clean::NameValue(ref x, ref s) - if "html_logo_url" == *x => { - cx.layout.logo = s.to_string(); - } - clean::NameValue(ref x, ref s) - if "html_playground_url" == *x => { - cx.layout.playground_url = s.to_string(); - markdown::PLAYGROUND_KRATE.with(|slot| { - if slot.borrow().is_none() { - let name = krate.name.clone(); - *slot.borrow_mut() = Some(Some(name)); - } - }); - } - clean::NameValue(ref x, ref s) - if "issue_tracker_base_url" == *x => { - cx.issue_tracker_base_url = Some(s.to_string()); - } - clean::Word(ref x) - if "html_no_source" == *x => { - cx.include_sources = false; - } - _ => {} + if let Some(attrs) = krate.module.as_ref().map(|m| m.attrs.list_def("doc")) { + for attr in attrs { + match *attr { + clean::NameValue(ref x, ref s) + if "html_favicon_url" == *x => { + cx.layout.favicon = s.to_string(); } + clean::NameValue(ref x, ref s) + if "html_logo_url" == *x => { + cx.layout.logo = s.to_string(); + } + clean::NameValue(ref x, ref s) + if "html_playground_url" == *x => { + cx.layout.playground_url = s.to_string(); + markdown::PLAYGROUND_KRATE.with(|slot| { + if slot.borrow().is_none() { + let name = krate.name.clone(); + *slot.borrow_mut() = Some(Some(name)); + } + }); + } + clean::NameValue(ref x, ref s) + if "issue_tracker_base_url" == *x => { + cx.issue_tracker_base_url = Some(s.to_string()); + } + clean::Word(ref x) + if "html_no_source" == *x => { + cx.include_sources = false; + } + _ => {} } } - None => {} } // Crawl the crate to build various caches used for the output @@ -770,11 +767,8 @@ fn render_sources(cx: &mut Context, try_err!(mkdir(&dst), &dst); let mut folder = SourceCollector { dst: dst, - seen: HashSet::new(), cx: cx, }; - // skip all invalid spans - folder.seen.insert("".to_string()); Ok(folder.fold_crate(krate)) } @@ -838,35 +832,26 @@ fn extern_location(e: &clean::ExternalCrate, dst: &Path) -> ExternalLocation { // Failing that, see if there's an attribute specifying where to find this // external crate - for attr in &e.attrs { - match *attr { - clean::List(ref x, ref list) if "doc" == *x => { - for attr in list { - match *attr { - clean::NameValue(ref x, ref s) - if "html_root_url" == *x => { - if s.ends_with("/") { - return Remote(s.to_string()); - } - return Remote(format!("{}/", s)); - } - _ => {} - } - } - } - _ => {} + e.attrs.list_def("doc").value("html_root_url").map(|url| { + let mut url = url.to_owned(); + if !url.ends_with("/") { + url.push('/') } - } - - // Well, at least we tried. - return Unknown; + Remote(url) + }).unwrap_or(Unknown) // Well, at least we tried. } impl<'a> DocFolder for SourceCollector<'a> { fn fold_item(&mut self, item: clean::Item) -> Option<clean::Item> { // If we're including source files, and we haven't seen this file yet, // then we need to render it out to the filesystem - if self.cx.include_sources && !self.seen.contains(&item.source.filename) { + if self.cx.include_sources + // skip all invalid spans + && item.source.filename != "" + // macros from other libraries get special filenames which we can + // safely ignore + && !(item.source.filename.starts_with("<") + && item.source.filename.ends_with("macros>")) { // If it turns out that we couldn't read this file, then we probably // can't read any of the files (generating html output from json or @@ -884,7 +869,6 @@ impl<'a> DocFolder for SourceCollector<'a> { false } }; - self.seen.insert(item.source.filename.clone()); } self.fold_item_recur(item) @@ -895,19 +879,14 @@ impl<'a> SourceCollector<'a> { /// Renders the given filename into its corresponding HTML source file. fn emit_source(&mut self, filename: &str) -> io::Result<()> { let p = PathBuf::from(filename); + if self.cx.local_sources.contains_key(&p) { + // We've already emitted this source + return Ok(()); + } - // If we couldn't open this file, then just returns because it - // probably means that it's some standard library macro thing and we - // can't have the source to it anyway. let mut contents = Vec::new(); - match File::open(&p).and_then(|mut f| f.read_to_end(&mut contents)) { - Ok(r) => r, - // macros from other libraries get special filenames which we can - // safely ignore - Err(..) if filename.starts_with("<") && - filename.ends_with("macros>") => return Ok(()), - Err(e) => return Err(e) - }; + try!(File::open(&p).and_then(|mut f| f.read_to_end(&mut contents))); + let contents = str::from_utf8(&contents).unwrap(); // Remove the utf-8 BOM if any @@ -920,16 +899,20 @@ impl<'a> SourceCollector<'a> { // Create the intermediate directories let mut cur = self.dst.clone(); let mut root_path = String::from("../../"); + let mut href = String::new(); clean_srcpath(&self.cx.src_root, &p, false, |component| { cur.push(component); mkdir(&cur).unwrap(); root_path.push_str("../"); + href.push_str(component); + href.push('/'); }); - let mut fname = p.file_name().expect("source has no filename") .to_os_string(); fname.push(".html"); cur.push(&fname[..]); + href.push_str(&fname.to_string_lossy()); + let mut w = BufWriter::new(try!(File::create(&cur))); let title = format!("{} -- source", cur.file_name().unwrap() .to_string_lossy()); @@ -939,12 +922,13 @@ impl<'a> SourceCollector<'a> { ty: "source", root_path: &root_path, description: &desc, - keywords: get_basic_keywords(), + keywords: BASIC_KEYWORDS, }; try!(layout::render(&mut w, &self.cx.layout, &page, &(""), &Source(contents))); try!(w.flush()); - return Ok(()); + self.cx.local_sources.insert(p, href); + Ok(()) } } @@ -983,15 +967,12 @@ impl DocFolder for Cache { // Collect all the implementors of traits. if let clean::ImplItem(ref i) = item.inner { - match i.trait_ { - Some(clean::ResolvedPath{ did, .. }) => { - self.implementors.entry(did).or_insert(vec![]).push(Implementor { - def_id: item.def_id, - stability: item.stability.clone(), - impl_: i.clone(), - }); - } - Some(..) | None => {} + if let Some(clean::ResolvedPath{ did, .. }) = i.trait_ { + self.implementors.entry(did).or_insert(vec![]).push(Implementor { + def_id: item.def_id, + stability: item.stability.clone(), + impl_: i.clone(), + }); } } @@ -1051,6 +1032,9 @@ impl DocFolder for Cache { } }); + // A crate has a module at its root, containing all items, + // which should not be indexed. The crate-item itself is + // inserted later on when serializing the search-index. if item.def_id.index != CRATE_DEF_INDEX { self.search_index.push(IndexItem { ty: shortty(&item), @@ -1075,13 +1059,14 @@ impl DocFolder for Cache { } // Keep track of the fully qualified path for this item. - let pushed = if item.name.is_some() { - let n = item.name.as_ref().unwrap(); - if !n.is_empty() { + let pushed = match item.name { + Some(ref n) if !n.is_empty() => { self.stack.push(n.to_string()); true - } else { false } - } else { false }; + } + _ => false, + }; + match item.inner { clean::StructItem(..) | clean::EnumItem(..) | clean::TypedefItem(..) | clean::TraitItem(..) | @@ -1150,60 +1135,40 @@ impl DocFolder for Cache { // Once we've recursively found all the generics, then hoard off all the // implementations elsewhere - let ret = match self.fold_item_recur(item) { - Some(item) => { - match item { - clean::Item{ attrs, inner: clean::ImplItem(i), .. } => { - // extract relevant documentation for this impl - let dox = match attrs.into_iter().find(|a| { - match *a { - clean::NameValue(ref x, _) - if "doc" == *x => { - true - } - _ => false - } - }) { - Some(clean::NameValue(_, dox)) => Some(dox), - Some(..) | None => None, - }; - - // Figure out the id of this impl. This may map to a - // primitive rather than always to a struct/enum. - let did = match i.for_ { - clean::ResolvedPath { did, .. } | - clean::BorrowedRef { - type_: box clean::ResolvedPath { did, .. }, .. - } => { - Some(did) - } - - ref t => { - t.primitive_type().and_then(|t| { - self.primitive_locations.get(&t).map(|n| { - let id = t.to_def_index(); - DefId { krate: *n, index: id } - }) - }) - } - }; - - if let Some(did) = did { - self.impls.entry(did).or_insert(vec![]).push(Impl { - impl_: i, - dox: dox, - stability: item.stability.clone(), - }); - } + let ret = self.fold_item_recur(item).and_then(|item| { + if let clean::Item { attrs, inner: clean::ImplItem(i), .. } = item { + // Figure out the id of this impl. This may map to a + // primitive rather than always to a struct/enum. + let did = match i.for_ { + clean::ResolvedPath { did, .. } | + clean::BorrowedRef { + type_: box clean::ResolvedPath { did, .. }, .. + } => { + Some(did) + } - None + ref t => { + t.primitive_type().and_then(|t| { + self.primitive_locations.get(&t).map(|n| { + let id = t.to_def_index(); + DefId { krate: *n, index: id } + }) + }) } + }; - i => Some(i), + if let Some(did) = did { + self.impls.entry(did).or_insert(vec![]).push(Impl { + impl_: i, + dox: attrs.value("doc").map(|s|s.to_owned()), + stability: item.stability.clone(), + }); } + None + } else { + Some(item) } - i => i, - }; + }); if pushed { self.stack.pop().unwrap(); } if parent_pushed { self.parent_stack.pop().unwrap(); } @@ -1301,11 +1266,7 @@ impl Context { } title.push_str(" - Rust"); let tyname = shortty(it).to_static_str(); - let is_crate = match it.inner { - clean::ModuleItem(clean::Module { items: _, is_crate: true }) => true, - _ => false - }; - let desc = if is_crate { + let desc = if it.is_crate() { format!("API documentation for the Rust `{}` crate.", cx.layout.krate) } else { @@ -1459,7 +1420,7 @@ impl<'a> Item<'a> { /// If `None` is returned, then a source link couldn't be generated. This /// may happen, for example, with externally inlined items where the source /// of their crate documentation isn't known. - fn href(&self, cx: &Context) -> Option<String> { + fn href(&self) -> Option<String> { let href = if self.item.source.loline == self.item.source.hiline { format!("{}", self.item.source.loline) } else { @@ -1492,25 +1453,13 @@ impl<'a> Item<'a> { // know the span, so we plow forward and generate a proper url. The url // has anchors for the line numbers that we're linking to. } else if self.item.def_id.is_local() { - let mut path = Vec::new(); - clean_srcpath(&cx.src_root, Path::new(&self.item.source.filename), - true, |component| { - path.push(component.to_string()); - }); - - // If the span points into an external macro the - // source-file will be bogus, i.e `<foo macros>` - let filename = &self.item.source.filename; - if !(filename.starts_with("<") && filename.ends_with("macros>")) { - Some(format!("{root}src/{krate}/{path}.html#{href}", - root = self.cx.root_path, - krate = self.cx.layout.krate, - path = path.join("/"), - href = href)) - } else { - None - } - + self.cx.local_sources.get(&PathBuf::from(&self.item.source.filename)).map(|path| { + format!("{root}src/{krate}/{path}.html#{href}", + root = self.cx.root_path, + krate = self.cx.layout.krate, + path = path, + href = href) + }) // If this item is not part of the local crate, then things get a little // trickier. We don't actually know the span of the external item, but // we know that the documentation on the other end knows the span! @@ -1590,13 +1539,10 @@ impl<'a> fmt::Display for Item<'a> { // this page, and this link will be auto-clicked. The `id` attribute is // used to find the link to auto-click. if self.cx.include_sources && !is_primitive { - match self.href(self.cx) { - Some(l) => { - try!(write!(fmt, "<a id='src-{}' class='srclink' \ - href='{}' title='{}'>[src]</a>", - self.item.def_id.index.as_usize(), l, "goto source code")); - } - None => {} + if let Some(l) = self.href() { + try!(write!(fmt, "<a id='src-{}' class='srclink' \ + href='{}' title='{}'>[src]</a>", + self.item.def_id.index.as_usize(), l, "goto source code")); } } @@ -1810,7 +1756,7 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context, } fn short_stability(item: &clean::Item, cx: &Context, show_reason: bool) -> Option<String> { - let mut result = item.stability.as_ref().and_then(|stab| { + item.stability.as_ref().and_then(|stab| { let reason = if show_reason && !stab.reason.is_empty() { format!(": {}", stab.reason) } else { @@ -1845,10 +1791,8 @@ fn short_stability(item: &clean::Item, cx: &Context, show_reason: bool) -> Optio }; Some(format!("<em class='stab {}'>{}</em>", item.stability_class(), text)) - }); - - if result.is_none() { - result = item.deprecation.as_ref().and_then(|depr| { + }).or_else(|| { + item.deprecation.as_ref().and_then(|depr| { let note = if show_reason && !depr.note.is_empty() { format!(": {}", depr.note) } else { @@ -1862,10 +1806,8 @@ fn short_stability(item: &clean::Item, cx: &Context, show_reason: bool) -> Optio let text = format!("Deprecated{}{}", since, Markdown(¬e)); Some(format!("<em class='stab deprecated'>{}</em>", text)) - }); - } - - result + }) + }) } struct Initializer<'a>(&'a str); @@ -1945,18 +1887,10 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item, bounds, WhereClause(&t.generics))); - let types = t.items.iter().filter(|m| { - match m.inner { clean::AssociatedTypeItem(..) => true, _ => false } - }).collect::<Vec<_>>(); - let consts = t.items.iter().filter(|m| { - match m.inner { clean::AssociatedConstItem(..) => true, _ => false } - }).collect::<Vec<_>>(); - let required = t.items.iter().filter(|m| { - match m.inner { clean::TyMethodItem(_) => true, _ => false } - }).collect::<Vec<_>>(); - let provided = t.items.iter().filter(|m| { - match m.inner { clean::MethodItem(_) => true, _ => false } - }).collect::<Vec<_>>(); + let types = t.items.iter().filter(|m| m.is_associated_type()).collect::<Vec<_>>(); + let consts = t.items.iter().filter(|m| m.is_associated_const()).collect::<Vec<_>>(); + let required = t.items.iter().filter(|m| m.is_ty_method()).collect::<Vec<_>>(); + let provided = t.items.iter().filter(|m| m.is_method()).collect::<Vec<_>>(); if t.items.is_empty() { try!(write!(w, "{{ }}")); @@ -2117,17 +2051,12 @@ fn assoc_type(w: &mut fmt::Formatter, it: &clean::Item, fn render_stability_since_raw<'a>(w: &mut fmt::Formatter, ver: Option<&'a str>, containing_ver: Option<&'a str>) -> fmt::Result { - if containing_ver != ver { - match ver { - Some(v) => - if v.len() > 0 { - try!(write!(w, "<span class=\"since\">{}</span>", - v)) - }, - None => {} + if let Some(v) = ver { + if containing_ver != ver && v.len() > 0 { + try!(write!(w, "<span class=\"since\">{}</span>", + v)) } } - Ok(()) } @@ -2298,43 +2227,33 @@ fn item_enum(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item, try!(write!(w, "<tr><td id='variant.{name}'><code>{name}</code></td><td>", name = variant.name.as_ref().unwrap())); try!(document(w, cx, variant)); - match variant.inner { - clean::VariantItem(ref var) => { - match var.kind { - clean::StructVariant(ref s) => { - let fields = s.fields.iter().filter(|f| { - match f.inner { - clean::StructFieldItem(ref t) => match *t { - clean::HiddenStructField => false, - clean::TypedStructField(..) => true, - }, - _ => false, - } - }); - try!(write!(w, "<h3 class='fields'>Fields</h3>\n - <table>")); - for field in fields { - try!(write!(w, "<tr><td \ - id='variant.{v}.field.{f}'>\ - <code>{f}</code></td><td>", - v = variant.name.as_ref().unwrap(), - f = field.name.as_ref().unwrap())); - try!(document(w, cx, field)); - try!(write!(w, "</td></tr>")); - } - try!(write!(w, "</table>")); - } - _ => () + + use clean::{Variant, StructVariant}; + if let clean::VariantItem( Variant { kind: StructVariant(ref s) } ) = variant.inner { + let fields = s.fields.iter().filter(|f| { + match f.inner { + clean::StructFieldItem(clean::TypedStructField(..)) => true, + _ => false, } + }); + try!(write!(w, "<h3 class='fields'>Fields</h3>\n + <table>")); + for field in fields { + try!(write!(w, "<tr><td \ + id='variant.{v}.field.{f}'>\ + <code>{f}</code></td><td>", + v = variant.name.as_ref().unwrap(), + f = field.name.as_ref().unwrap())); + try!(document(w, cx, field)); + try!(write!(w, "</td></tr>")); } - _ => () + try!(write!(w, "</table>")); } try!(write!(w, "</td><td>")); try!(render_stability_since(w, variant, it)); try!(write!(w, "</td></tr>")); } try!(write!(w, "</table>")); - } try!(render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)); Ok(()) @@ -2365,9 +2284,8 @@ fn render_struct(w: &mut fmt::Formatter, it: &clean::Item, VisSpace(it.visibility), if structhead {"struct "} else {""}, it.name.as_ref().unwrap())); - match g { - Some(g) => try!(write!(w, "{}{}", *g, WhereClause(g))), - None => {} + if let Some(g) = g { + try!(write!(w, "{}{}", *g, WhereClause(g))) } match ty { doctree::Plain => { @@ -2461,7 +2379,7 @@ fn render_assoc_items(w: &mut fmt::Formatter, } } if let AssocItemRender::DerefFor { .. } = what { - return Ok(()) + return Ok(()); } if !traits.is_empty() { let deref_impl = traits.iter().find(|t| { @@ -2542,10 +2460,17 @@ fn render_impl(w: &mut fmt::Formatter, cx: &Context, i: &Impl, link: AssocItemLi link: AssocItemLink, render_static: bool, outer_version: Option<&str>) -> fmt::Result { let name = item.name.as_ref().unwrap(); + + let is_static = match item.inner { + clean::MethodItem(ref method) => method.self_ == SelfTy::SelfStatic, + clean::TyMethodItem(ref method) => method.self_ == SelfTy::SelfStatic, + _ => false + }; + match item.inner { clean::MethodItem(..) | clean::TyMethodItem(..) => { // Only render when the method is not static or we allow static methods - if !is_static_method(item) || render_static { + if !is_static || render_static { let id = derive_id(format!("method.{}", name)); try!(write!(w, "<h4 id='{}' class='{}'>", id, shortty(item))); try!(render_stability_since_raw(w, item.stable_since(), outer_version)); @@ -2581,22 +2506,11 @@ fn render_impl(w: &mut fmt::Formatter, cx: &Context, i: &Impl, link: AssocItemLi _ => panic!("can't make docs for trait item with name {:?}", item.name) } - return if let AssocItemLink::Anchor = link { - if is_static_method(item) && !render_static { - Ok(()) - } else { + match link { + AssocItemLink::Anchor if !is_static || render_static => { document(w, cx, 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 - } + }, + _ => Ok(()), } } @@ -2614,9 +2528,8 @@ fn render_impl(w: &mut fmt::Formatter, cx: &Context, i: &Impl, link: AssocItemLi outer_version: Option<&str>) -> 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 => {} + if i.items.iter().find(|m| { m.name == n }).is_some() { + continue; } try!(doctraititem(w, cx, trait_item, AssocItemLink::GotoSource(did), render_static, @@ -2632,7 +2545,6 @@ fn render_impl(w: &mut fmt::Formatter, cx: &Context, i: &Impl, link: AssocItemLi if let Some(clean::ResolvedPath { did, .. }) = i.impl_.trait_ { if let Some(t) = cache().traits.get(&did) { try!(render_default_items(w, cx, did, t, &i.impl_, render_header, outer_version)); - } } try!(write!(w, "</div>")); @@ -2676,7 +2588,7 @@ impl<'a> fmt::Display for Sidebar<'a> { try!(write!(fmt, "</p>")); // sidebar refers to the enclosing module, not this module - let relpath = if shortty(it) == ItemType::Module { "../" } else { "" }; + let relpath = if it.is_mod() { "../" } else { "" }; try!(write!(fmt, "<script>window.sidebarCurrent = {{\ name: '{name}', \ @@ -2734,12 +2646,10 @@ fn item_primitive(w: &mut fmt::Formatter, cx: &Context, render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All) } -fn get_basic_keywords() -> &'static str { - "rust, rustlang, rust-lang" -} +const BASIC_KEYWORDS: &'static str = "rust, rustlang, rust-lang"; fn make_item_keywords(it: &clean::Item) -> String { - format!("{}, {}", get_basic_keywords(), it.name.as_ref().unwrap()) + format!("{}, {}", BASIC_KEYWORDS, it.name.as_ref().unwrap()) } fn get_index_search_type(item: &clean::Item, diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs index ffb15d157b0..3c7aadb3533 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -94,6 +94,8 @@ pub mod visit_ast; pub mod test; mod flock; +use clean::Attributes; + type Pass = (&'static str, // name fn(clean::Crate) -> plugins::PluginResult, // fn &'static str); // description @@ -283,19 +285,15 @@ pub fn main_args(args: &[String]) -> isize { info!("going to format"); match matches.opt_str("w").as_ref().map(|s| &**s) { Some("html") | None => { - match html::render::run(krate, &external_html, - output.unwrap_or(PathBuf::from("doc")), - passes.into_iter().collect()) { - Ok(()) => {} - Err(e) => panic!("failed to generate documentation: {}", e), - } + html::render::run(krate, &external_html, + output.unwrap_or(PathBuf::from("doc")), + passes.into_iter().collect()) + .expect("failed to generate documentation") } Some("json") => { - match json_output(krate, json_plugins, - output.unwrap_or(PathBuf::from("doc.json"))) { - Ok(()) => {} - Err(e) => panic!("failed to write json: {}", e), - } + json_output(krate, json_plugins, + output.unwrap_or(PathBuf::from("doc.json"))) + .expect("failed to write json") } Some(s) => { println!("unknown output format: {}", s); @@ -332,18 +330,10 @@ fn parse_externs(matches: &getopts::Matches) -> Result<core::Externs, String> { let mut externs = HashMap::new(); for arg in &matches.opt_strs("extern") { let mut parts = arg.splitn(2, '='); - let name = match parts.next() { - Some(s) => s, - None => { - return Err("--extern value must not be empty".to_string()); - } - }; - let location = match parts.next() { - Some(s) => s, - None => { - return Err("--extern value must be of the format `foo=bar`".to_string()); - } - }; + let name = try!(parts.next().ok_or("--extern value must not be empty".to_string())); + let location = try!(parts.next() + .ok_or("--extern value must be of the format `foo=bar`" + .to_string())); let name = name.to_string(); externs.entry(name).or_insert(vec![]).push(location.to_string()); } @@ -391,32 +381,25 @@ fn rust_input(cratefile: &str, externs: core::Externs, matches: &getopts::Matche // Process all of the crate attributes, extracting plugin metadata along // with the passes which we are supposed to run. - match krate.module.as_ref().unwrap().doc_list() { - Some(nested) => { - for inner in nested { - match *inner { - clean::Word(ref x) - if "no_default_passes" == *x => { - default_passes = false; - } - clean::NameValue(ref x, ref value) - if "passes" == *x => { - for pass in value.split_whitespace() { - passes.push(pass.to_string()); - } - } - clean::NameValue(ref x, ref value) - if "plugins" == *x => { - for p in value.split_whitespace() { - plugins.push(p.to_string()); - } - } - _ => {} + for attr in krate.module.as_ref().unwrap().attrs.list_def("doc") { + match *attr { + clean::Word(ref w) if "no_default_passes" == *w => { + default_passes = false; + }, + clean::NameValue(ref name, ref value) => { + let sink = match &name[..] { + "passes" => &mut passes, + "plugins" => &mut plugins, + _ => continue, + }; + for p in value.split_whitespace() { + sink.push(p.to_string()); } } + _ => (), } - None => {} } + if default_passes { for name in DEFAULT_PASSES.iter().rev() { passes.insert(0, name.to_string()); @@ -448,17 +431,16 @@ fn rust_input(cratefile: &str, externs: core::Externs, matches: &getopts::Matche // Run everything! info!("Executing passes/plugins"); let (krate, json) = pm.run_plugins(krate); - return Output { krate: krate, json_plugins: json, passes: passes, }; + Output { krate: krate, json_plugins: json, passes: passes } } /// This input format purely deserializes the json output file. No passes are /// run over the deserialized output. fn json_input(input: &str) -> Result<Output, String> { let mut bytes = Vec::new(); - match File::open(input).and_then(|mut f| f.read_to_end(&mut bytes)) { - Ok(_) => {} - Err(e) => return Err(format!("couldn't open {}: {}", input, e)), - }; + if let Err(e) = File::open(input).and_then(|mut f| f.read_to_end(&mut bytes)) { + return Err(format!("couldn't open {}: {}", input, e)) + } match json::from_reader(&mut &bytes[..]) { Err(s) => Err(format!("{:?}", s)), Ok(Json::Object(obj)) => { @@ -507,21 +489,13 @@ fn json_output(krate: clean::Crate, res: Vec<plugins::PluginJson> , json.insert("schema".to_string(), Json::String(SCHEMA_VERSION.to_string())); let plugins_json = res.into_iter() .filter_map(|opt| { - match opt { - None => None, - Some((string, json)) => { - Some((string.to_string(), json)) - } - } + opt.map(|(string, json)| (string.to_string(), json)) }).collect(); // FIXME #8335: yuck, Rust -> str -> JSON round trip! No way to .encode // straight to the Rust JSON representation. let crate_json_str = format!("{}", json::as_json(&krate)); - let crate_json = match json::from_str(&crate_json_str) { - Ok(j) => j, - Err(e) => panic!("Rust generated JSON is invalid: {:?}", e) - }; + let crate_json = json::from_str(&crate_json_str).expect("Rust generated JSON is invalid"); json.insert("crate".to_string(), crate_json); json.insert("plugins".to_string(), Json::Object(plugins_json)); diff --git a/src/librustdoc/passes.rs b/src/librustdoc/passes.rs index 957957eaec6..6f6a72fa9fe 100644 --- a/src/librustdoc/passes.rs +++ b/src/librustdoc/passes.rs @@ -16,7 +16,7 @@ use std::string::String; use std::usize; use rustc_front::hir; -use clean; +use clean::{self, Attributes}; use clean::Item; use plugins; use fold; @@ -33,7 +33,7 @@ pub fn strip_hidden(krate: clean::Crate) -> plugins::PluginResult { } impl<'a> fold::DocFolder for Stripper<'a> { fn fold_item(&mut self, i: Item) -> Option<Item> { - if i.is_hidden_from_doc() { + if i.attrs.list_def("doc").has_word("hidden") { debug!("found one in strip_hidden; removing"); self.stripped.insert(i.def_id); @@ -205,22 +205,19 @@ impl<'a> fold::DocFolder for Stripper<'a> { self.fold_item_recur(i) }; - match i { - Some(i) => { - match i.inner { - // emptied modules/impls have no need to exist - clean::ModuleItem(ref m) - if m.items.is_empty() && - i.doc_value().is_none() => None, - clean::ImplItem(ref i) if i.items.is_empty() => None, - _ => { - self.retained.insert(i.def_id); - Some(i) - } + i.and_then(|i| { + match i.inner { + // emptied modules/impls have no need to exist + clean::ModuleItem(ref m) + if m.items.is_empty() && + i.doc_value().is_none() => None, + clean::ImplItem(ref i) if i.items.is_empty() => None, + _ => { + self.retained.insert(i.def_id); + Some(i) } } - None => None, - } + }) } } @@ -246,8 +243,7 @@ impl<'a> fold::DocFolder for ImplStripper<'a> { pub fn unindent_comments(krate: clean::Crate) -> plugins::PluginResult { struct CommentCleaner; impl fold::DocFolder for CommentCleaner { - fn fold_item(&mut self, i: Item) -> Option<Item> { - let mut i = i; + fn fold_item(&mut self, mut i: Item) -> Option<Item> { let mut avec: Vec<clean::Attribute> = Vec::new(); for attr in &i.attrs { match attr { @@ -271,17 +267,14 @@ pub fn unindent_comments(krate: clean::Crate) -> plugins::PluginResult { pub fn collapse_docs(krate: clean::Crate) -> plugins::PluginResult { struct Collapser; impl fold::DocFolder for Collapser { - fn fold_item(&mut self, i: Item) -> Option<Item> { + fn fold_item(&mut self, mut i: Item) -> Option<Item> { let mut docstr = String::new(); - let mut i = i; for attr in &i.attrs { - match *attr { - clean::NameValue(ref x, ref s) - if "doc" == *x => { + if let clean::NameValue(ref x, ref s) = *attr { + if "doc" == *x { docstr.push_str(s); docstr.push('\n'); - }, - _ => () + } } } let mut a: Vec<clean::Attribute> = i.attrs.iter().filter(|&a| match a { diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs index 39550488a9e..e97357f9889 100644 --- a/src/librustdoc/test.rs +++ b/src/librustdoc/test.rs @@ -121,9 +121,8 @@ pub fn run(input: &str, let mut v = RustdocVisitor::new(&ctx, None); v.visit(ctx.map.krate()); let mut krate = v.clean(&ctx); - match crate_name { - Some(name) => krate.name = name, - None => {} + if let Some(name) = crate_name { + krate.name = name; } let (krate, _) = passes::collapse_docs(krate); let (krate, _) = passes::unindent_comments(krate); @@ -334,13 +333,10 @@ pub fn maketest(s: &str, cratename: Option<&str>, dont_insert_main: bool, // Don't inject `extern crate std` because it's already injected by the // compiler. if !s.contains("extern crate") && !opts.no_crate_inject && cratename != Some("std") { - match cratename { - Some(cratename) => { - if s.contains(cratename) { - prog.push_str(&format!("extern crate {};\n", cratename)); - } + if let Some(cratename) = cratename { + if s.contains(cratename) { + prog.push_str(&format!("extern crate {};\n", cratename)); } - None => {} } } if dont_insert_main || s.contains("fn main") { @@ -476,12 +472,7 @@ impl DocFolder for Collector { _ => typename_if_impl(&item) }; - let pushed = if let Some(name) = current_name { - self.names.push(name); - true - } else { - false - }; + let pushed = current_name.map(|name| self.names.push(name)).is_some(); if let Some(doc) = item.doc_value() { self.cnt = 0; diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs index ba389bc42b7..bc6b4f83984 100644 --- a/src/librustdoc/visit_ast.rs +++ b/src/librustdoc/visit_ast.rs @@ -263,13 +263,9 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { let name = renamed.unwrap_or(item.name); match item.node { hir::ItemExternCrate(ref p) => { - let path = match *p { - None => None, - Some(x) => Some(x.to_string()), - }; om.extern_crates.push(ExternCrate { name: name, - path: path, + path: p.map(|x|x.to_string()), vis: item.vis, attrs: item.attrs.clone(), whence: item.span, |