1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
|
#![feature(rustc_private)]
extern crate rustc_driver;
use std::env;
use std::error::Error;
use std::fs::{self, File};
use std::io::Write;
use std::path::Path;
use std::path::PathBuf;
use std::str::FromStr;
use mdbook::book::{parse_summary, BookItem, Chapter};
use mdbook::{Config, MDBook};
enum OutputFormat {
HTML,
Markdown,
Unknown(String),
}
impl OutputFormat {
fn from(format: &str) -> OutputFormat {
match &*format.to_lowercase() {
"html" => OutputFormat::HTML,
"markdown" => OutputFormat::Markdown,
s => OutputFormat::Unknown(s.to_owned()),
}
}
}
/// Output an HTML page for the errors in `err_map` to `output_path`.
fn render_markdown(output_path: &Path) -> Result<(), Box<dyn Error>> {
let mut output_file = File::create(output_path)?;
write!(output_file, "# Rust Compiler Error Index\n")?;
for (err_code, description) in rustc_error_codes::DIAGNOSTICS.iter() {
write!(output_file, "## {}\n{}\n", err_code, description)?
}
Ok(())
}
// By default, mdbook doesn't consider code blocks as Rust ones contrary to rustdoc so we have
// to manually add `rust` attribute whenever needed.
fn add_rust_attribute_on_codeblock(explanation: &str) -> String {
// Very hacky way to add the rust attribute on all code blocks.
let mut skip = true;
explanation.split("\n```").fold(String::new(), |mut acc, part| {
if !acc.is_empty() {
acc.push_str("\n```");
}
if !skip {
if let Some(attrs) = part.split('\n').next() {
if !attrs.contains("rust")
&& (attrs.is_empty()
|| attrs.contains("compile_fail")
|| attrs.contains("ignore")
|| attrs.contains("edition"))
{
if !attrs.is_empty() {
acc.push_str("rust,");
} else {
acc.push_str("rust");
}
}
}
}
skip = !skip;
acc.push_str(part);
acc
})
}
fn render_html(output_path: &Path) -> Result<(), Box<dyn Error>> {
let mut introduction = format!(
"# Rust error codes index
This page lists all the error codes emitted by the Rust compiler.
"
);
let err_codes = rustc_error_codes::DIAGNOSTICS;
let mut chapters = Vec::with_capacity(err_codes.len());
for (err_code, explanation) in err_codes.iter() {
introduction.push_str(&format!(" * [{0}](./{0}.html)\n", err_code));
let content = add_rust_attribute_on_codeblock(explanation);
chapters.push(BookItem::Chapter(Chapter {
name: err_code.to_string(),
content: format!("# Error code {}\n\n{}\n", err_code, content),
number: None,
sub_items: Vec::new(),
// We generate it into the `error_codes` folder.
path: Some(PathBuf::from(&format!("{}.html", err_code))),
source_path: None,
parent_names: Vec::new(),
}));
}
let mut config = Config::from_str(include_str!("book_config.toml"))?;
config.build.build_dir = output_path.join("error_codes").to_path_buf();
let mut book = MDBook::load_with_config_and_summary(
env!("CARGO_MANIFEST_DIR"),
config,
parse_summary("")?,
)?;
let chapter = Chapter {
name: "Rust error codes index".to_owned(),
content: introduction,
number: None,
sub_items: chapters,
// Very important: this file is named as `error-index.html` and not `index.html`!
path: Some(PathBuf::from("error-index.html")),
source_path: None,
parent_names: Vec::new(),
};
book.book.sections.push(BookItem::Chapter(chapter));
book.build()?;
// The error-index used to be generated manually (without mdbook), and the
// index was located at the top level. Now that it is generated with
// mdbook, error-index.html has moved to error_codes/error-index.html.
// This adds a redirect so that old links go to the new location.
//
// We can't put this content into another file, otherwise `mdbook` will also put it into the
// output directory, making a duplicate.
fs::write(
output_path.join("error-index.html"),
r#"<!DOCTYPE html>
<html>
<head>
<title>Rust error codes index - Error codes index</title>
<meta content="text/html; charset=utf-8" http-equiv="Content-Type">
<meta name="description" content="Book listing all Rust error codes">
<script src="error_codes/redirect.js"></script>
</head>
<body>
<div>If you are not automatically redirected to the error code index, please <a id="index-link" href="./error_codes/error-index.html">here</a>.
</body>
</html>"#,
)?;
Ok(())
}
fn main_with_result(format: OutputFormat, dst: &Path) -> Result<(), Box<dyn Error>> {
match format {
OutputFormat::Unknown(s) => panic!("Unknown output format: {}", s),
OutputFormat::HTML => render_html(dst),
OutputFormat::Markdown => render_markdown(dst),
}
}
fn parse_args() -> (OutputFormat, PathBuf) {
let mut args = env::args().skip(1);
let format = args.next();
let dst = args.next();
let format = format.map(|a| OutputFormat::from(&a)).unwrap_or(OutputFormat::from("html"));
let dst = dst.map(PathBuf::from).unwrap_or_else(|| match format {
OutputFormat::HTML => PathBuf::from("doc"),
OutputFormat::Markdown => PathBuf::from("doc/error-index.md"),
OutputFormat::Unknown(..) => PathBuf::from("<nul>"),
});
(format, dst)
}
fn main() {
rustc_driver::init_env_logger("RUST_LOG");
let (format, dst) = parse_args();
let result = main_with_result(format, &dst);
if let Err(e) = result {
panic!("{:?}", e);
}
}
|
