user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Auto merge of #31967 - mitaa:rdoc-refactor, r=alexcrichton

Browse source 
This is mostly cleanup of individual code bits and code reuse for `clean::Attribute` handling.

The only change in behaviour should be that emitted sources are now being recorded and queried when trying to create src-links to local source-files.

r? @alexcrichton
This commit is contained in:
bors 2016-03-06 09:16:32 +00:00
commit 21fb3ce71b
8 changed files with 357 additions and 543 deletions
Download patch file Download diff file Expand all files Collapse all files

45
src/librustdoc/clean/inline.rs
View file

@ -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(..) => {}

220
src/librustdoc/clean/mod.rs
View file

@ -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 {

39
src/librustdoc/fold.rs
View file

@ -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
}
}

432
src/librustdoc/html/render.rs
View file

@ -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(),
});
}
None
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)
}
i => Some(i),
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: 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(&note));
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,

94
src/librustdoc/lib.rs
View file

@ -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));

43
src/librustdoc/passes.rs
View file

@ -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 {

21
src/librustdoc/test.rs
View file

@ -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;

6
src/librustdoc/visit_ast.rs
View file

@ -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,