diff --git a/library/core/src/marker.rs b/library/core/src/marker.rs index 2c57897956fcd..ab673c623b5d6 100644 --- a/library/core/src/marker.rs +++ b/library/core/src/marker.rs @@ -343,7 +343,7 @@ pub trait StructuralEq { /// If you try to implement `Copy` on a struct or enum containing non-`Copy` data, you will get /// the error [E0204]. /// -/// [E0204]: ../../error-index.html#E0204 +/// [E0204]: ../../error_codes/E0204.html /// /// ## When *should* my type be `Copy`? /// diff --git a/library/core/src/ops/drop.rs b/library/core/src/ops/drop.rs index aa654aa5570ee..de9ddb852df31 100644 --- a/library/core/src/ops/drop.rs +++ b/library/core/src/ops/drop.rs @@ -156,7 +156,7 @@ pub trait Drop { /// handled by the compiler, but when using unsafe code, can sometimes occur /// unintentionally, particularly when using [`ptr::drop_in_place`]. /// - /// [E0040]: ../../error-index.html#E0040 + /// [E0040]: ../../error_codes/E0040.html /// [`panic!`]: crate::panic! /// [`mem::drop`]: drop /// [`ptr::drop_in_place`]: crate::ptr::drop_in_place diff --git a/src/tools/error_index_generator/build.rs b/src/tools/error_index_generator/build.rs deleted file mode 100644 index 70b00b36cf175..0000000000000 --- a/src/tools/error_index_generator/build.rs +++ /dev/null @@ -1,31 +0,0 @@ -use std::path::PathBuf; -use std::{env, fs}; -use walkdir::WalkDir; - -fn main() { - // The src directory (we are in src/tools/error_index_generator) - // Note that we could skip one of the .. but this ensures we at least loosely find the right - // directory. - let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap()); - - let error_codes_path = "../../../compiler/rustc_error_codes/src/error_codes.rs"; - - println!("cargo:rerun-if-changed={}", error_codes_path); - let file = fs::read_to_string(error_codes_path) - .unwrap() - .replace(": include_str!(\"./error_codes/", ": include_str!(\"./"); - let contents = format!("(|| {{\n{}\n}})()", file); - fs::write(&out_dir.join("all_error_codes.rs"), &contents).unwrap(); - - // We copy the md files as well to the target directory. - for entry in WalkDir::new("../../../compiler/rustc_error_codes/src/error_codes") { - let entry = entry.unwrap(); - match entry.path().extension() { - Some(s) if s == "md" => {} - _ => continue, - } - println!("cargo:rerun-if-changed={}", entry.path().to_str().unwrap()); - let md_content = fs::read_to_string(entry.path()).unwrap(); - fs::write(&out_dir.join(entry.file_name()), &md_content).unwrap(); - } -} diff --git a/src/tools/error_index_generator/main.rs b/src/tools/error_index_generator/main.rs index 1ce02e48c05b6..68c46700361a8 100644 --- a/src/tools/error_index_generator/main.rs +++ b/src/tools/error_index_generator/main.rs @@ -3,11 +3,11 @@ extern crate rustc_driver; extern crate rustc_span; -use std::cell::RefCell; -use std::collections::BTreeMap; +use crate::error_codes::error_codes; + use std::env; use std::error::Error; -use std::fs::File; +use std::fs::{create_dir_all, File}; use std::io::Write; use std::path::Path; use std::path::PathBuf; @@ -16,49 +16,86 @@ use rustc_span::edition::DEFAULT_EDITION; use rustdoc::html::markdown::{ErrorCodes, HeadingOffset, IdMap, Markdown, Playground}; -pub struct ErrorMetadata { - pub description: Option, +macro_rules! register_diagnostics { + ($($error_code:ident: $message:expr,)+ ; $($undocumented:ident,)* ) => { + pub fn error_codes() -> Vec<(&'static str, Option<&'static str>)> { + let mut errors: Vec<(&str, Option<&str>)> = vec![ + $((stringify!($error_code), Some($message)),)+ + $((stringify!($undocumented), None),)+ + ]; + errors.sort(); + errors + } + } } -/// Mapping from error codes to metadata that can be (de)serialized. -pub type ErrorMetadataMap = BTreeMap; +#[path = "../../../compiler/rustc_error_codes/src/error_codes.rs"] +mod error_codes; enum OutputFormat { HTML(HTMLFormatter), - Markdown(MarkdownFormatter), + Markdown, Unknown(String), } impl OutputFormat { fn from(format: &str, resource_suffix: &str) -> OutputFormat { match &*format.to_lowercase() { - "html" => OutputFormat::HTML(HTMLFormatter( - RefCell::new(IdMap::new()), - resource_suffix.to_owned(), - )), - "markdown" => OutputFormat::Markdown(MarkdownFormatter), + "html" => OutputFormat::HTML(HTMLFormatter(resource_suffix.to_owned())), + "markdown" => OutputFormat::Markdown, s => OutputFormat::Unknown(s.to_owned()), } } } -trait Formatter { - fn header(&self, output: &mut dyn Write) -> Result<(), Box>; - fn title(&self, output: &mut dyn Write) -> Result<(), Box>; - fn error_code_block( +struct HTMLFormatter(String); + +impl HTMLFormatter { + fn create_error_code_file( &self, - output: &mut dyn Write, - info: &ErrorMetadata, err_code: &str, - ) -> Result<(), Box>; - fn footer(&self, output: &mut dyn Write) -> Result<(), Box>; -} + explanation: &str, + parent_dir: &Path, + ) -> Result<(), Box> { + let mut output_file = File::create(parent_dir.join(err_code).with_extension("html"))?; + + self.header(&mut output_file, "../", "")?; + self.title(&mut output_file, &format!("Error code {}", err_code))?; + + let mut id_map = IdMap::new(); + let playground = + Playground { crate_name: None, url: String::from("https://play.rust-lang.org/") }; + write!( + output_file, + "{}", + Markdown { + content: explanation, + links: &[], + ids: &mut id_map, + error_codes: ErrorCodes::Yes, + edition: DEFAULT_EDITION, + playground: &Some(playground), + heading_offset: HeadingOffset::H1, + } + .into_string() + )?; + write!( + output_file, + "

\ + Back to list of error codes\ +

", + )?; -struct HTMLFormatter(RefCell, String); -struct MarkdownFormatter; + self.footer(&mut output_file) + } -impl Formatter for HTMLFormatter { - fn header(&self, output: &mut dyn Write) -> Result<(), Box> { + fn header( + &self, + output: &mut dyn Write, + extra_path: &str, + extra: &str, + ) -> Result<(), Box> { write!( output, r##" @@ -67,188 +104,106 @@ impl Formatter for HTMLFormatter { Rust Compiler Error Index - - - + + + +{extra} "##, - suffix = self.1 + suffix = self.0, )?; Ok(()) } - fn title(&self, output: &mut dyn Write) -> Result<(), Box> { - write!(output, "

Rust Compiler Error Index

\n")?; - Ok(()) - } - - fn error_code_block( - &self, - output: &mut dyn Write, - info: &ErrorMetadata, - err_code: &str, - ) -> Result<(), Box> { - // Enclose each error in a div so they can be shown/hidden en masse. - let desc_desc = match info.description { - Some(_) => "error-described", - None => "error-undescribed", - }; - write!(output, "
", desc_desc)?; - - // Error title (with self-link). - write!( - output, - "

{0}

\n", - err_code - )?; - - // Description rendered as markdown. - match info.description { - Some(ref desc) => { - let mut id_map = self.0.borrow_mut(); - let playground = Playground { - crate_name: None, - url: String::from("https://play.rust-lang.org/"), - }; - write!( - output, - "{}", - Markdown { - content: desc, - links: &[], - ids: &mut id_map, - error_codes: ErrorCodes::Yes, - edition: DEFAULT_EDITION, - playground: &Some(playground), - heading_offset: HeadingOffset::H1, - } - .into_string() - )? - } - None => write!(output, "

No description.

\n")?, - } - - write!(output, "
\n")?; + fn title(&self, output: &mut dyn Write, title: &str) -> Result<(), Box> { + write!(output, "

{}

\n", title)?; Ok(()) } fn footer(&self, output: &mut dyn Write) -> Result<(), Box> { - write!( - output, - r##" - -"## - )?; + write!(output, "")?; Ok(()) } } -impl Formatter for MarkdownFormatter { - #[allow(unused_variables)] - fn header(&self, output: &mut dyn Write) -> Result<(), Box> { - Ok(()) - } +/// Output an HTML page for the errors in `err_map` to `output_path`. +fn render_markdown(output_path: &Path) -> Result<(), Box> { + let mut output_file = File::create(output_path)?; - fn title(&self, output: &mut dyn Write) -> Result<(), Box> { - write!(output, "# Rust Compiler Error Index\n")?; - Ok(()) - } + write!(output_file, "# Rust Compiler Error Index\n")?; - fn error_code_block( - &self, - output: &mut dyn Write, - info: &ErrorMetadata, - err_code: &str, - ) -> Result<(), Box> { - Ok(match info.description { - Some(ref desc) => write!(output, "## {}\n{}\n", err_code, desc)?, - None => (), - }) + for (err_code, description) in error_codes().iter() { + match description { + Some(ref desc) => write!(output_file, "## {}\n{}\n", err_code, desc)?, + None => {} + } } - #[allow(unused_variables)] - fn footer(&self, output: &mut dyn Write) -> Result<(), Box> { - Ok(()) - } + Ok(()) } -/// Output an HTML page for the errors in `err_map` to `output_path`. -fn render_error_page( - err_map: &ErrorMetadataMap, - output_path: &Path, - formatter: T, -) -> Result<(), Box> { +fn render_html(output_path: &Path, formatter: HTMLFormatter) -> Result<(), Box> { let mut output_file = File::create(output_path)?; - formatter.header(&mut output_file)?; - formatter.title(&mut output_file)?; + let error_codes_dir = "error_codes"; - for (err_code, info) in err_map { - formatter.error_code_block(&mut output_file, info, err_code)?; + let parent = output_path.parent().expect("There should have a parent").join(error_codes_dir); + + if !parent.exists() { + create_dir_all(&parent)?; } + formatter.header( + &mut output_file, + "", + &format!( + r#""# + ), + )?; + formatter.title(&mut output_file, "Rust Compiler Error Index")?; + + write!( + output_file, + "

This page lists all the error codes emitted by the Rust compiler. If you want a full \ + explanation on an error code, click on it.

\ +
    ", + )?; + for (err_code, explanation) in error_codes().iter() { + if let Some(explanation) = explanation { + write!( + output_file, + "
  • {1}
    • ", + error_codes_dir, err_code + )?; + formatter.create_error_code_file(err_code, explanation, &parent)?; + } else { + write!(output_file, "
  • {}
    • ", err_code)?; + } + } + write!(output_file, "
")?; formatter.footer(&mut output_file) } fn main_with_result(format: OutputFormat, dst: &Path) -> Result<(), Box> { - let long_codes = register_all(); - let mut err_map = BTreeMap::new(); - for (code, desc) in long_codes { - err_map.insert(code.to_string(), ErrorMetadata { description: desc.map(String::from) }); - } match format { OutputFormat::Unknown(s) => panic!("Unknown output format: {}", s), - OutputFormat::HTML(h) => render_error_page(&err_map, dst, h)?, - OutputFormat::Markdown(m) => render_error_page(&err_map, dst, m)?, + OutputFormat::HTML(h) => render_html(dst, h), + OutputFormat::Markdown => render_markdown(dst), } - Ok(()) } fn parse_args() -> (OutputFormat, PathBuf) { @@ -261,7 +216,7 @@ fn parse_args() -> (OutputFormat, PathBuf) { .unwrap_or(OutputFormat::from("html", &resource_suffix)); let dst = dst.map(PathBuf::from).unwrap_or_else(|| match format { OutputFormat::HTML(..) => PathBuf::from("doc/error-index.html"), - OutputFormat::Markdown(..) => PathBuf::from("doc/error-index.md"), + OutputFormat::Markdown => PathBuf::from("doc/error-index.md"), OutputFormat::Unknown(..) => PathBuf::from(""), }); (format, dst) @@ -276,23 +231,3 @@ fn main() { panic!("{}", e.to_string()); } } - -fn register_all() -> Vec<(&'static str, Option<&'static str>)> { - let mut long_codes: Vec<(&'static str, Option<&'static str>)> = Vec::new(); - macro_rules! register_diagnostics { - ($($ecode:ident: $message:expr,)* ; $($code:ident,)*) => ( - $( - {long_codes.extend([ - (stringify!($ecode), Some($message)), - ].iter());} - )* - $( - {long_codes.extend([ - stringify!($code), - ].iter().cloned().map(|s| (s, None)).collect::>());} - )* - ) - } - include!(concat!(env!("OUT_DIR"), "/all_error_codes.rs")); - long_codes -}