"minifier 0.0.30 (registry+https://github.com/rust-lang/crates.io-index)",
"parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
"pulldown-cmark 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-rayon 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"tempfile 3.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
//! needs to read-after-write from a file, then it would be added to this
//! abstraction.
+use errors;
+
+use std::cell::RefCell;
use std::fs;
use std::io;
use std::path::Path;
+use std::sync::Arc;
+use std::sync::mpsc::{channel, Receiver, Sender};
macro_rules! try_err {
($e:expr, $file:expr) => {{
fn new<P: AsRef<Path>>(e: io::Error, path: P) -> Self;
}
+pub struct ErrorStorage {
+ sender: Sender<Option<String>>,
+ receiver: Receiver<Option<String>>,
+}
+
+impl ErrorStorage {
+ pub fn new() -> ErrorStorage {
+ let (sender, receiver) = channel();
+ ErrorStorage {
+ sender,
+ receiver,
+ }
+ }
+
+ /// Prints all stored errors. Returns the number of printed errors.
+ pub fn write_errors(&self, diag: &errors::Handler) -> usize {
+ let mut printed = 0;
+ drop(self.sender);
+
+ for msg in self.receiver.iter() {
+ if let Some(ref error) = msg {
+ diag.struct_err(&error).emit();
+ printed += 1;
+ }
+ }
+ printed
+ }
+}
+
pub struct DocFS {
sync_only: bool,
+ errors: Arc<ErrorStorage>,
}
impl DocFS {
- pub fn new() -> DocFS {
+ pub fn new(errors: &Arc<ErrorStorage>) -> DocFS {
DocFS {
sync_only: false,
+ errors: Arc::clone(errors),
}
}
// be to create the file sync so errors are reported eagerly.
let contents = contents.as_ref().to_vec();
let path = path.as_ref().to_path_buf();
- rayon::spawn(move ||
+ let sender = self.errors.sender.clone();
+ rayon::spawn(move || {
match fs::write(&path, &contents) {
- Ok(_) => (),
+ Ok(_) => {
+ sender.send(None)
+ .expect(&format!("failed to send error on \"{}\"", path.display()));
+ }
Err(e) => {
- // In principle these should get displayed at the top
- // level, but just in case, send to stderr as well.
- eprintln!("\"{}\": {}", path.display(), e);
- panic!("\"{}\": {}", path.display(), e);
+ sender.send(Some(format!("\"{}\": {}", path.display(), e)))
+ .expect(&format!("failed to send non-error on \"{}\"", path.display()));
}
- });
+ }
+ });
Ok(())
} else {
Ok(try_err!(fs::write(&path, contents), path))
use crate::clean::{self, AttributesExt, Deprecation, GetDefId, SelfTy, Mutability};
use crate::config::RenderOptions;
-use crate::docfs::{DocFS, PathError};
+use crate::docfs::{DocFS, ErrorStorage, PathError};
use crate::doctree;
use crate::fold::DocFolder;
use crate::html::escape::Escape;
impl Display for Error {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
- write!(f, "\"{}\": {}", self.file.display(), self.error)
+ let file = self.file.display().to_string();
+ if file.is_empty() {
+ write!(f, "{}", self.error)
+ } else {
+ write!(f, "\"{}\": {}", self.file.display(), self.error)
+ }
}
}
},
_ => PathBuf::new(),
};
+ let errors = Arc::new(ErrorStorage::new());
let mut scx = SharedContext {
src_root,
passes,
static_root_path,
generate_search_filter,
generate_redirect_pages,
- fs: DocFS::new(),
+ fs: DocFS::new(&errors),
};
// If user passed in `--playground-url` arg, we fill in crate name here
Arc::get_mut(&mut cx.shared).unwrap().fs.set_sync_only(false);
// And finally render the whole crate's documentation
- cx.krate(krate)
+ let ret = cx.krate(krate);
+ let nb_errors = errors.write_errors(diag);
+ if ret.is_err() {
+ ret
+ } else if nb_errors > 0 {
+ Err(Error::new(io::Error::new(io::ErrorKind::Other, "I/O error"), ""))
+ } else {
+ Ok(())
+ }
}
/// Builds the search index from the collected metadata