1 // Copyright 2016 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 //! Documentation generation for rustbuilder.
13 //! This module implements generation for all bits and pieces of documentation
14 //! for the Rust project. This notably includes suites like the rust book, the
15 //! nomicon, rust by example, standalone documentation, etc.
17 //! Everything here is basically just a shim around calling either `rustbook` or
20 use std::collections::HashSet;
21 use std::fs::{self, File};
22 use std::io::prelude::*;
24 use std::path::{PathBuf, Path};
27 use build_helper::up_to_date;
29 use util::symlink_dir;
30 use builder::{Builder, Compiler, RunConfig, ShouldRun, Step};
31 use tool::{self, prepare_tool_cargo, Tool};
33 use cache::{INTERNER, Interned};
37 ($($name:ident, $path:expr, $book_name:expr;)+) => {
39 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
41 target: Interned<String>,
46 const DEFAULT: bool = true;
48 fn should_run(run: ShouldRun) -> ShouldRun {
49 let builder = run.builder;
50 run.path($path).default_condition(builder.config.docs)
53 fn make_run(run: RunConfig) {
54 run.builder.ensure($name {
59 fn run(self, builder: &Builder) {
60 builder.ensure(Rustbook {
62 name: INTERNER.intern_str($book_name),
71 Nomicon, "src/doc/nomicon", "nomicon";
72 Reference, "src/doc/reference", "reference";
73 RustdocBook, "src/doc/rustdoc", "rustdoc";
74 RustcBook, "src/doc/rustc", "rustc";
75 RustByExample, "src/doc/rust-by-example", "rust-by-example";
78 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
80 target: Interned<String>,
81 name: Interned<String>,
84 impl Step for Rustbook {
87 // rustbook is never directly called, and only serves as a shim for the nomicon and the
89 fn should_run(run: ShouldRun) -> ShouldRun {
93 /// Invoke `rustbook` for `target` for the doc book `name`.
95 /// This will not actually generate any documentation if the documentation has
96 /// already been generated.
97 fn run(self, builder: &Builder) {
98 let src = builder.src.join("src/doc");
99 builder.ensure(RustbookSrc {
102 src: INTERNER.intern_path(src),
107 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
108 pub struct UnstableBook {
109 target: Interned<String>,
112 impl Step for UnstableBook {
114 const DEFAULT: bool = true;
116 fn should_run(run: ShouldRun) -> ShouldRun {
117 let builder = run.builder;
118 run.path("src/doc/unstable-book").default_condition(builder.config.docs)
121 fn make_run(run: RunConfig) {
122 run.builder.ensure(UnstableBook {
127 fn run(self, builder: &Builder) {
128 builder.ensure(UnstableBookGen {
131 builder.ensure(RustbookSrc {
133 name: INTERNER.intern_str("unstable-book"),
134 src: builder.md_doc_out(self.target),
139 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
140 pub struct CargoBook {
141 target: Interned<String>,
142 name: Interned<String>,
145 impl Step for CargoBook {
147 const DEFAULT: bool = true;
149 fn should_run(run: ShouldRun) -> ShouldRun {
150 let builder = run.builder;
151 run.path("src/tools/cargo/src/doc/book").default_condition(builder.config.docs)
154 fn make_run(run: RunConfig) {
155 run.builder.ensure(CargoBook {
157 name: INTERNER.intern_str("cargo"),
161 fn run(self, builder: &Builder) {
162 let target = self.target;
163 let name = self.name;
164 let src = builder.src.join("src/tools/cargo/src/doc");
166 let out = builder.doc_out(target);
167 t!(fs::create_dir_all(&out));
169 let out = out.join(name);
171 builder.info(&format!("Cargo Book ({}) - {}", target, name));
173 let _ = fs::remove_dir_all(&out);
175 builder.run(builder.tool_cmd(Tool::Rustbook)
183 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
185 target: Interned<String>,
186 name: Interned<String>,
187 src: Interned<PathBuf>,
190 impl Step for RustbookSrc {
193 fn should_run(run: ShouldRun) -> ShouldRun {
197 /// Invoke `rustbook` for `target` for the doc book `name` from the `src` path.
199 /// This will not actually generate any documentation if the documentation has
200 /// already been generated.
201 fn run(self, builder: &Builder) {
202 let target = self.target;
203 let name = self.name;
205 let out = builder.doc_out(target);
206 t!(fs::create_dir_all(&out));
208 let out = out.join(name);
209 let src = src.join(name);
210 let index = out.join("index.html");
211 let rustbook = builder.tool_exe(Tool::Rustbook);
212 let mut rustbook_cmd = builder.tool_cmd(Tool::Rustbook);
213 if up_to_date(&src, &index) && up_to_date(&rustbook, &index) {
216 builder.info(&format!("Rustbook ({}) - {}", target, name));
217 let _ = fs::remove_dir_all(&out);
218 builder.run(rustbook_cmd
226 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
229 target: Interned<String>,
233 impl Step for TheBook {
235 const DEFAULT: bool = true;
237 fn should_run(run: ShouldRun) -> ShouldRun {
238 let builder = run.builder;
239 run.path("src/doc/book").default_condition(builder.config.docs)
242 fn make_run(run: RunConfig) {
243 run.builder.ensure(TheBook {
244 compiler: run.builder.compiler(run.builder.top_stage, run.builder.config.build),
250 /// Build the book and associated stuff.
252 /// We need to build:
254 /// * Book (first edition)
255 /// * Book (second edition)
256 /// * Version info and CSS
259 fn run(self, builder: &Builder) {
260 let compiler = self.compiler;
261 let target = self.target;
262 let name = self.name;
263 // build book first edition
264 builder.ensure(Rustbook {
266 name: INTERNER.intern_string(format!("{}/first-edition", name)),
269 // build book second edition
270 builder.ensure(Rustbook {
272 name: INTERNER.intern_string(format!("{}/second-edition", name)),
275 // build book 2018 edition
276 builder.ensure(Rustbook {
278 name: INTERNER.intern_string(format!("{}/2018-edition", name)),
281 // build the version info page and CSS
282 builder.ensure(Standalone {
287 // build the index page
288 let index = format!("{}/index.md", name);
289 builder.info(&format!("Documenting book index ({})", target));
290 invoke_rustdoc(builder, compiler, target, &index);
292 // build the redirect pages
293 builder.info(&format!("Documenting book redirect pages ({})", target));
294 for file in t!(fs::read_dir(builder.src.join("src/doc/book/redirects"))) {
296 let path = file.path();
297 let path = path.to_str().unwrap();
299 invoke_rustdoc(builder, compiler, target, path);
304 fn invoke_rustdoc(builder: &Builder, compiler: Compiler, target: Interned<String>, markdown: &str) {
305 let out = builder.doc_out(target);
307 let path = builder.src.join("src/doc").join(markdown);
309 let favicon = builder.src.join("src/doc/favicon.inc");
310 let footer = builder.src.join("src/doc/footer.inc");
311 let version_info = out.join("version_info.html");
313 let mut cmd = builder.rustdoc_cmd(compiler.host);
315 let out = out.join("book");
317 cmd.arg("--html-after-content").arg(&footer)
318 .arg("--html-before-content").arg(&version_info)
319 .arg("--html-in-header").arg(&favicon)
320 .arg("--markdown-no-toc")
321 .arg("--markdown-playground-url")
322 .arg("https://play.rust-lang.org/")
325 .arg("--markdown-css")
328 builder.run(&mut cmd);
331 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
332 pub struct Standalone {
334 target: Interned<String>,
337 impl Step for Standalone {
339 const DEFAULT: bool = true;
341 fn should_run(run: ShouldRun) -> ShouldRun {
342 let builder = run.builder;
343 run.path("src/doc").default_condition(builder.config.docs)
346 fn make_run(run: RunConfig) {
347 run.builder.ensure(Standalone {
348 compiler: run.builder.compiler(run.builder.top_stage, run.builder.config.build),
353 /// Generates all standalone documentation as compiled by the rustdoc in `stage`
354 /// for the `target` into `out`.
356 /// This will list all of `src/doc` looking for markdown files and appropriately
357 /// perform transformations like substituting `VERSION`, `SHORT_HASH`, and
358 /// `STAMP` along with providing the various header/footer HTML we've customized.
360 /// In the end, this is just a glorified wrapper around rustdoc!
361 fn run(self, builder: &Builder) {
362 let target = self.target;
363 let compiler = self.compiler;
364 builder.info(&format!("Documenting standalone ({})", target));
365 let out = builder.doc_out(target);
366 t!(fs::create_dir_all(&out));
368 let favicon = builder.src.join("src/doc/favicon.inc");
369 let footer = builder.src.join("src/doc/footer.inc");
370 let full_toc = builder.src.join("src/doc/full-toc.inc");
371 t!(fs::copy(builder.src.join("src/doc/rust.css"), out.join("rust.css")));
373 let version_input = builder.src.join("src/doc/version_info.html.template");
374 let version_info = out.join("version_info.html");
376 if !builder.config.dry_run && !up_to_date(&version_input, &version_info) {
377 let mut info = String::new();
378 t!(t!(File::open(&version_input)).read_to_string(&mut info));
379 let info = info.replace("VERSION", &builder.rust_release())
380 .replace("SHORT_HASH", builder.rust_info.sha_short().unwrap_or(""))
381 .replace("STAMP", builder.rust_info.sha().unwrap_or(""));
382 t!(t!(File::create(&version_info)).write_all(info.as_bytes()));
385 for file in t!(fs::read_dir(builder.src.join("src/doc"))) {
387 let path = file.path();
388 let filename = path.file_name().unwrap().to_str().unwrap();
389 if !filename.ends_with(".md") || filename == "README.md" {
393 let html = out.join(filename).with_extension("html");
394 let rustdoc = builder.rustdoc(compiler.host);
395 if up_to_date(&path, &html) &&
396 up_to_date(&footer, &html) &&
397 up_to_date(&favicon, &html) &&
398 up_to_date(&full_toc, &html) &&
399 up_to_date(&version_info, &html) &&
400 (builder.config.dry_run || up_to_date(&rustdoc, &html)) {
404 let mut cmd = builder.rustdoc_cmd(compiler.host);
405 cmd.arg("--html-after-content").arg(&footer)
406 .arg("--html-before-content").arg(&version_info)
407 .arg("--html-in-header").arg(&favicon)
408 .arg("--markdown-playground-url")
409 .arg("https://play.rust-lang.org/")
413 if filename == "not_found.md" {
414 cmd.arg("--markdown-no-toc")
415 .arg("--markdown-css")
416 .arg("https://doc.rust-lang.org/rust.css");
418 cmd.arg("--markdown-css").arg("rust.css");
420 builder.run(&mut cmd);
425 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
428 pub target: Interned<String>,
433 const DEFAULT: bool = true;
435 fn should_run(run: ShouldRun) -> ShouldRun {
436 let builder = run.builder;
437 run.all_krates("std").default_condition(builder.config.docs)
440 fn make_run(run: RunConfig) {
441 run.builder.ensure(Std {
442 stage: run.builder.top_stage,
447 /// Compile all standard library documentation.
449 /// This will generate all documentation for the standard library and its
450 /// dependencies. This is largely just a wrapper around `cargo doc`.
451 fn run(self, builder: &Builder) {
452 let stage = self.stage;
453 let target = self.target;
454 builder.info(&format!("Documenting stage{} std ({})", stage, target));
455 let out = builder.doc_out(target);
456 t!(fs::create_dir_all(&out));
457 let compiler = builder.compiler(stage, builder.config.build);
458 let rustdoc = builder.rustdoc(compiler.host);
459 let compiler = if builder.force_use_stage1(compiler, target) {
460 builder.compiler(1, compiler.host)
465 builder.ensure(compile::Std { compiler, target });
466 let out_dir = builder.stage_out(compiler, Mode::Std)
467 .join(target).join("doc");
469 // Here what we're doing is creating a *symlink* (directory junction on
470 // Windows) to the final output location. This is not done as an
471 // optimization but rather for correctness. We've got three trees of
472 // documentation, one for std, one for test, and one for rustc. It's then
473 // our job to merge them all together.
475 // Unfortunately rustbuild doesn't know nearly as well how to merge doc
476 // trees as rustdoc does itself, so instead of actually having three
477 // separate trees we just have rustdoc output to the same location across
480 // This way rustdoc generates output directly into the output, and rustdoc
481 // will also directly handle merging.
482 let my_out = builder.crate_doc_out(target);
483 builder.clear_if_dirty(&my_out, &rustdoc);
484 t!(symlink_dir_force(&builder.config, &my_out, &out_dir));
486 let mut cargo = builder.cargo(compiler, Mode::Std, target, "doc");
487 compile::std_cargo(builder, &compiler, target, &mut cargo);
489 // Keep a whitelist so we do not build internal stdlib crates, these will be
490 // build by the rustc step later if enabled.
491 cargo.arg("--no-deps");
492 for krate in &["alloc", "core", "std", "std_unicode"] {
493 cargo.arg("-p").arg(krate);
494 // Create all crate output directories first to make sure rustdoc uses
496 // FIXME: Cargo should probably do this itself.
497 t!(fs::create_dir_all(out_dir.join(krate)));
500 builder.run(&mut cargo);
501 builder.cp_r(&my_out, &out);
505 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
508 target: Interned<String>,
513 const DEFAULT: bool = true;
515 fn should_run(run: ShouldRun) -> ShouldRun {
516 let builder = run.builder;
517 run.krate("test").default_condition(builder.config.docs)
520 fn make_run(run: RunConfig) {
521 run.builder.ensure(Test {
522 stage: run.builder.top_stage,
527 /// Compile all libtest documentation.
529 /// This will generate all documentation for libtest and its dependencies. This
530 /// is largely just a wrapper around `cargo doc`.
531 fn run(self, builder: &Builder) {
532 let stage = self.stage;
533 let target = self.target;
534 builder.info(&format!("Documenting stage{} test ({})", stage, target));
535 let out = builder.doc_out(target);
536 t!(fs::create_dir_all(&out));
537 let compiler = builder.compiler(stage, builder.config.build);
538 let rustdoc = builder.rustdoc(compiler.host);
539 let compiler = if builder.force_use_stage1(compiler, target) {
540 builder.compiler(1, compiler.host)
545 // Build libstd docs so that we generate relative links
546 builder.ensure(Std { stage, target });
548 builder.ensure(compile::Test { compiler, target });
549 let out_dir = builder.stage_out(compiler, Mode::Test)
550 .join(target).join("doc");
552 // See docs in std above for why we symlink
553 let my_out = builder.crate_doc_out(target);
554 builder.clear_if_dirty(&my_out, &rustdoc);
555 t!(symlink_dir_force(&builder.config, &my_out, &out_dir));
557 let mut cargo = builder.cargo(compiler, Mode::Test, target, "doc");
558 compile::test_cargo(builder, &compiler, target, &mut cargo);
560 cargo.arg("--no-deps").arg("-p").arg("test");
562 builder.run(&mut cargo);
563 builder.cp_r(&my_out, &out);
567 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
568 pub struct WhitelistedRustc {
570 target: Interned<String>,
573 impl Step for WhitelistedRustc {
575 const DEFAULT: bool = true;
576 const ONLY_HOSTS: bool = true;
578 fn should_run(run: ShouldRun) -> ShouldRun {
579 let builder = run.builder;
580 run.krate("rustc-main").default_condition(builder.config.docs)
583 fn make_run(run: RunConfig) {
584 run.builder.ensure(WhitelistedRustc {
585 stage: run.builder.top_stage,
590 /// Generate whitelisted compiler crate documentation.
592 /// This will generate all documentation for crates that are whitelisted
593 /// to be included in the standard documentation. This documentation is
594 /// included in the standard Rust documentation, so we should always
595 /// document it and symlink to merge with the rest of the std and test
596 /// documentation. We don't build other compiler documentation
597 /// here as we want to be able to keep it separate from the standard
598 /// documentation. This is largely just a wrapper around `cargo doc`.
599 fn run(self, builder: &Builder) {
600 let stage = self.stage;
601 let target = self.target;
602 builder.info(&format!("Documenting stage{} whitelisted compiler ({})", stage, target));
603 let out = builder.doc_out(target);
604 t!(fs::create_dir_all(&out));
605 let compiler = builder.compiler(stage, builder.config.build);
606 let rustdoc = builder.rustdoc(compiler.host);
607 let compiler = if builder.force_use_stage1(compiler, target) {
608 builder.compiler(1, compiler.host)
613 // Build libstd docs so that we generate relative links
614 builder.ensure(Std { stage, target });
616 builder.ensure(compile::Rustc { compiler, target });
617 let out_dir = builder.stage_out(compiler, Mode::Rustc)
618 .join(target).join("doc");
620 // See docs in std above for why we symlink
621 let my_out = builder.crate_doc_out(target);
622 builder.clear_if_dirty(&my_out, &rustdoc);
623 t!(symlink_dir_force(&builder.config, &my_out, &out_dir));
625 let mut cargo = builder.cargo(compiler, Mode::Rustc, target, "doc");
626 compile::rustc_cargo(builder, &mut cargo);
628 // We don't want to build docs for internal compiler dependencies in this
629 // step (there is another step for that). Therefore, we whitelist the crates
630 // for which docs must be built.
631 cargo.arg("--no-deps");
632 for krate in &["proc_macro"] {
633 cargo.arg("-p").arg(krate);
636 builder.run(&mut cargo);
637 builder.cp_r(&my_out, &out);
641 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
644 target: Interned<String>,
647 impl Step for Rustc {
649 const DEFAULT: bool = true;
650 const ONLY_HOSTS: bool = true;
652 fn should_run(run: ShouldRun) -> ShouldRun {
653 let builder = run.builder;
654 run.krate("rustc-main").default_condition(builder.config.docs)
657 fn make_run(run: RunConfig) {
658 run.builder.ensure(Rustc {
659 stage: run.builder.top_stage,
664 /// Generate compiler documentation.
666 /// This will generate all documentation for compiler and dependencies.
667 /// Compiler documentation is distributed separately, so we make sure
668 /// we do not merge it with the other documentation from std, test and
669 /// proc_macros. This is largely just a wrapper around `cargo doc`.
670 fn run(self, builder: &Builder) {
671 let stage = self.stage;
672 let target = self.target;
673 builder.info(&format!("Documenting stage{} compiler ({})", stage, target));
675 // This is the intended out directory for compiler documentation.
676 let out = builder.compiler_doc_out(target);
677 t!(fs::create_dir_all(&out));
679 // Get the correct compiler for this stage.
680 let compiler = builder.compiler(stage, builder.config.build);
681 let rustdoc = builder.rustdoc(compiler.host);
682 let compiler = if builder.force_use_stage1(compiler, target) {
683 builder.compiler(1, compiler.host)
688 if !builder.config.compiler_docs {
689 builder.info(&format!("\tskipping - compiler/librustdoc docs disabled"));
693 // Build libstd docs so that we generate relative links.
694 builder.ensure(Std { stage, target });
697 builder.ensure(compile::Rustc { compiler, target });
699 // We do not symlink to the same shared folder that already contains std library
700 // documentation from previous steps as we do not want to include that.
701 let out_dir = builder.stage_out(compiler, Mode::Rustc).join(target).join("doc");
702 builder.clear_if_dirty(&out, &rustdoc);
703 t!(symlink_dir_force(&builder.config, &out, &out_dir));
705 // Build cargo command.
706 let mut cargo = builder.cargo(compiler, Mode::Rustc, target, "doc");
707 cargo.env("RUSTDOCFLAGS", "--document-private-items");
708 compile::rustc_cargo(builder, &mut cargo);
710 // Only include compiler crates, no dependencies of those, such as `libc`.
711 cargo.arg("--no-deps");
713 // Find dependencies for top level crates.
714 let mut compiler_crates = HashSet::new();
715 for root_crate in &["rustc", "rustc_driver"] {
716 let interned_root_crate = INTERNER.intern_str(root_crate);
717 find_compiler_crates(builder, &interned_root_crate, &mut compiler_crates);
720 for krate in &compiler_crates {
721 cargo.arg("-p").arg(krate);
724 builder.run(&mut cargo);
728 fn find_compiler_crates(
730 name: &Interned<String>,
731 crates: &mut HashSet<Interned<String>>
733 // Add current crate.
734 crates.insert(*name);
736 // Look for dependencies.
737 for dep in builder.crates.get(name).unwrap().deps.iter() {
738 if builder.crates.get(dep).unwrap().is_local(builder) {
739 find_compiler_crates(builder, dep, crates);
744 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
747 target: Interned<String>,
750 impl Step for Rustdoc {
752 const DEFAULT: bool = true;
753 const ONLY_HOSTS: bool = true;
755 fn should_run(run: ShouldRun) -> ShouldRun {
756 run.krate("rustdoc-tool")
759 fn make_run(run: RunConfig) {
760 run.builder.ensure(Rustdoc {
761 stage: run.builder.top_stage,
766 /// Generate compiler documentation.
768 /// This will generate all documentation for compiler and dependencies.
769 /// Compiler documentation is distributed separately, so we make sure
770 /// we do not merge it with the other documentation from std, test and
771 /// proc_macros. This is largely just a wrapper around `cargo doc`.
772 fn run(self, builder: &Builder) {
773 let stage = self.stage;
774 let target = self.target;
775 builder.info(&format!("Documenting stage{} rustdoc ({})", stage, target));
777 // This is the intended out directory for compiler documentation.
778 let out = builder.compiler_doc_out(target);
779 t!(fs::create_dir_all(&out));
781 // Get the correct compiler for this stage.
782 let compiler = builder.compiler(stage, builder.config.build);
783 let rustdoc = builder.rustdoc(compiler.host);
784 let compiler = if builder.force_use_stage1(compiler, target) {
785 builder.compiler(1, compiler.host)
790 if !builder.config.compiler_docs {
791 builder.info(&format!("\tskipping - compiler/librustdoc docs disabled"));
795 // Build libstd docs so that we generate relative links.
796 builder.ensure(Std { stage, target });
799 builder.ensure(tool::Rustdoc { host: compiler.host });
801 // Symlink compiler docs to the output directory of rustdoc documentation.
802 let out_dir = builder.stage_out(compiler, Mode::ToolRustc)
805 t!(fs::create_dir_all(&out_dir));
806 builder.clear_if_dirty(&out, &rustdoc);
807 t!(symlink_dir_force(&builder.config, &out, &out_dir));
809 // Build cargo command.
810 let mut cargo = prepare_tool_cargo(
819 cargo.env("RUSTDOCFLAGS", "--document-private-items");
820 builder.run(&mut cargo);
824 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
825 pub struct ErrorIndex {
826 target: Interned<String>,
829 impl Step for ErrorIndex {
831 const DEFAULT: bool = true;
832 const ONLY_HOSTS: bool = true;
834 fn should_run(run: ShouldRun) -> ShouldRun {
835 let builder = run.builder;
836 run.path("src/tools/error_index_generator").default_condition(builder.config.docs)
839 fn make_run(run: RunConfig) {
840 run.builder.ensure(ErrorIndex {
845 /// Generates the HTML rendered error-index by running the
846 /// `error_index_generator` tool.
847 fn run(self, builder: &Builder) {
848 let target = self.target;
850 builder.info(&format!("Documenting error index ({})", target));
851 let out = builder.doc_out(target);
852 t!(fs::create_dir_all(&out));
853 let mut index = builder.tool_cmd(Tool::ErrorIndex);
855 index.arg(out.join("error-index.html"));
857 // FIXME: shouldn't have to pass this env var
858 index.env("CFG_BUILD", &builder.config.build)
859 .env("RUSTC_ERROR_METADATA_DST", builder.extended_error_dir());
861 builder.run(&mut index);
865 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
866 pub struct UnstableBookGen {
867 target: Interned<String>,
870 impl Step for UnstableBookGen {
872 const DEFAULT: bool = true;
873 const ONLY_HOSTS: bool = true;
875 fn should_run(run: ShouldRun) -> ShouldRun {
876 let builder = run.builder;
877 run.path("src/tools/unstable-book-gen").default_condition(builder.config.docs)
880 fn make_run(run: RunConfig) {
881 run.builder.ensure(UnstableBookGen {
886 fn run(self, builder: &Builder) {
887 let target = self.target;
889 builder.ensure(compile::Std {
890 compiler: builder.compiler(builder.top_stage, builder.config.build),
894 builder.info(&format!("Generating unstable book md files ({})", target));
895 let out = builder.md_doc_out(target).join("unstable-book");
896 builder.create_dir(&out);
897 builder.remove_dir(&out);
898 let mut cmd = builder.tool_cmd(Tool::UnstableBookGen);
899 cmd.arg(builder.src.join("src"));
902 builder.run(&mut cmd);
906 fn symlink_dir_force(config: &Config, src: &Path, dst: &Path) -> io::Result<()> {
910 if let Ok(m) = fs::symlink_metadata(dst) {
911 if m.file_type().is_dir() {
912 try!(fs::remove_dir_all(dst));
914 // handle directory junctions on windows by falling back to
916 try!(fs::remove_file(dst).or_else(|_| {
922 symlink_dir(config, src, dst)