bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Remove step.rs comments

Browse source
This commit is contained in:
Mark Simulacrum 2017-07-20 16:41:26 -06:00
parent 8563280bec
commit e9c2242050
7 changed files with 1 additions and 749 deletions
Download patch file Download diff file Expand all files Collapse all files

231
src/bootstrap/check.rs
View file

@ -87,13 +87,6 @@ fn try_run_quiet(build: &Build, cmd: &mut Command) {
}
}
// rules.test("check-linkchecker", "src/tools/linkchecker")
// .dep(|s| s.name("tool-linkchecker").stage(0))
// .dep(|s| s.name("default:doc"))
// .default(build.config.docs)
// .host(true)
// .run(move |s| check::linkcheck(build, s.target));
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct Linkcheck {
host: Interned<String>,
@ -141,12 +134,6 @@ impl Step for Linkcheck {
}
}
// rules.test("check-cargotest", "src/tools/cargotest")
// .dep(|s| s.name("tool-cargotest").stage(0))
// .dep(|s| s.name("librustc"))
// .host(true)
// .run(move |s| check::cargotest(build, s.stage, s.target));
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct Cargotest {
stage: u32,
@ -197,11 +184,6 @@ impl Step for Cargotest {
}
}
//rules.test("check-cargo", "cargo")
// .dep(|s| s.name("tool-cargo"))
// .host(true)
// .run(move |s| check::cargo(build, s.stage, s.target));
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct Cargo {
stage: u32,
@ -257,10 +239,6 @@ pub struct Rls {
host: Interned<String>,
}
// rules.test("check-rls", "src/tools/rls")
// .dep(|s| s.name("tool-rls"))
// .host(true)
// .run(move |s| check::rls(build, s.stage, s.target));
impl Step for Rls {
type Output = ();
const ONLY_HOSTS: bool = true;
@ -310,13 +288,6 @@ fn path_for_cargo(builder: &Builder, compiler: Compiler) -> OsString {
env::join_paths(iter::once(path).chain(env::split_paths(&old_path))).expect("")
}
//rules.test("check-tidy", "src/tools/tidy")
// .dep(|s| s.name("tool-tidy").stage(0))
// .default(true)
// .host(true)
// .only_build(true)
// .run(move |s| check::tidy(build, s.target));
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct Tidy {
host: Interned<String>,
@ -370,104 +341,6 @@ fn testdir(build: &Build, host: Interned<String>) -> PathBuf {
build.out.join(host).join("test")
}
// // ========================================================================
// // Test targets
// //
// // Various unit tests and tests suites we can run
// {
// let mut suite = |name, path, mode, dir| {
// rules.test(name, path)
// .dep(|s| s.name("libtest"))
// .dep(|s| s.name("tool-compiletest").target(s.host).stage(0))
// .dep(|s| s.name("test-helpers"))
// .dep(|s| s.name("remote-copy-libs"))
// .default(mode != "pretty") // pretty tests don't run everywhere
// .run(move |s| {
// check::compiletest(build, &s.compiler(), s.target, mode, dir)
// });
// };
//
// suite("check-ui", "src/test/ui", "ui", "ui");
// suite("check-rpass", "src/test/run-pass", "run-pass", "run-pass");
// suite("check-cfail", "src/test/compile-fail", "compile-fail", "compile-fail");
// suite("check-pfail", "src/test/parse-fail", "parse-fail", "parse-fail");
// suite("check-rfail", "src/test/run-fail", "run-fail", "run-fail");
// suite("check-rpass-valgrind", "src/test/run-pass-valgrind",
// "run-pass-valgrind", "run-pass-valgrind");
// suite("check-mir-opt", "src/test/mir-opt", "mir-opt", "mir-opt");
// if build.config.codegen_tests {
// suite("check-codegen", "src/test/codegen", "codegen", "codegen");
// }
// suite("check-codegen-units", "src/test/codegen-units", "codegen-units",
// "codegen-units");
// suite("check-incremental", "src/test/incremental", "incremental",
// "incremental");
// }
//
// if build.build.contains("msvc") {
// // nothing to do for debuginfo tests
// } else {
// rules.test("check-debuginfo-lldb", "src/test/debuginfo-lldb")
// .dep(|s| s.name("libtest"))
// .dep(|s| s.name("tool-compiletest").target(s.host).stage(0))
// .dep(|s| s.name("test-helpers"))
// .dep(|s| s.name("debugger-scripts"))
// .run(move |s| check::compiletest(build, &s.compiler(), s.target,
// "debuginfo-lldb", "debuginfo"));
// rules.test("check-debuginfo-gdb", "src/test/debuginfo-gdb")
// .dep(|s| s.name("libtest"))
// .dep(|s| s.name("tool-compiletest").target(s.host).stage(0))
// .dep(|s| s.name("test-helpers"))
// .dep(|s| s.name("debugger-scripts"))
// .dep(|s| s.name("remote-copy-libs"))
// .run(move |s| check::compiletest(build, &s.compiler(), s.target,
// "debuginfo-gdb", "debuginfo"));
// let mut rule = rules.test("check-debuginfo", "src/test/debuginfo");
// rule.default(true);
// if build.build.contains("apple") {
// rule.dep(|s| s.name("check-debuginfo-lldb"));
// } else {
// rule.dep(|s| s.name("check-debuginfo-gdb"));
// }
// }
//
//
//
// {
// let mut suite = |name, path, mode, dir| {
// rules.test(name, path)
// .dep(|s| s.name("librustc"))
// .dep(|s| s.name("test-helpers"))
// .dep(|s| s.name("tool-compiletest").target(s.host).stage(0))
// .default(mode != "pretty")
// .host(true)
// .run(move |s| {
// check::compiletest(build, &s.compiler(), s.target, mode, dir)
// });
// };
//
// suite("check-ui-full", "src/test/ui-fulldeps", "ui", "ui-fulldeps");
// suite("check-rpass-full", "src/test/run-pass-fulldeps",
// "run-pass", "run-pass-fulldeps");
// suite("check-rfail-full", "src/test/run-fail-fulldeps",
// "run-fail", "run-fail-fulldeps");
// suite("check-cfail-full", "src/test/compile-fail-fulldeps",
// "compile-fail", "compile-fail-fulldeps");
// suite("check-rmake", "src/test/run-make", "run-make", "run-make");
// suite("check-rustdoc", "src/test/rustdoc", "rustdoc", "rustdoc");
// suite("check-pretty", "src/test/pretty", "pretty", "pretty");
// suite("check-pretty-rpass", "src/test/run-pass/pretty", "pretty",
// "run-pass");
// suite("check-pretty-rfail", "src/test/run-fail/pretty", "pretty",
// "run-fail");
// suite("check-pretty-valgrind", "src/test/run-pass-valgrind/pretty", "pretty",
// "run-pass-valgrind");
// suite("check-pretty-rpass-full", "src/test/run-pass-fulldeps/pretty",
// "pretty", "run-pass-fulldeps");
// suite("check-pretty-rfail-full", "src/test/run-fail-fulldeps/pretty",
// "pretty", "run-fail-fulldeps");
// }
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
struct Test {
path: &'static str,
@ -862,11 +735,6 @@ pub struct Docs {
compiler: Compiler,
}
// rules.test("check-docs", "src/doc")
// .dep(|s| s.name("libtest"))
// .default(true)
// .host(true)
// .run(move |s| check::docs(build, &s.compiler()));
impl Step for Docs {
type Output = ();
const DEFAULT: bool = true;
@ -925,13 +793,6 @@ impl Step for Docs {
}
}
//rules.test("check-error-index", "src/tools/error_index_generator")
// .dep(|s| s.name("libstd"))
// .dep(|s| s.name("tool-error-index").host(s.host).stage(0))
// .default(true)
// .host(true)
// .run(move |s| check::error_index(build, &s.compiler()));
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct ErrorIndex {
compiler: Compiler,
@ -1013,22 +874,6 @@ fn markdown_test(builder: &Builder, compiler: Compiler, markdown: &Path) {
}
}
// for (krate, path, _default) in krates("rustc-main") {
// rules.test(&krate.test_step, path)
// .dep(|s| s.name("librustc"))
// .dep(|s| s.name("remote-copy-libs"))
// .host(true)
// .run(move |s| check::krate(build, &s.compiler(), s.target,
// Mode::Librustc, TestKind::Test,
// Some(&krate.name)));
// }
// rules.test("check-rustc-all", "path/to/nowhere")
// .dep(|s| s.name("librustc"))
// .dep(|s| s.name("remote-copy-libs"))
// .default(true)
// .host(true)
// .run(move |s| check::krate(build, &s.compiler(), s.target,
// Mode::Librustc, TestKind::Test, None));
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct CrateLibrustc {
compiler: Compiler,
@ -1095,52 +940,6 @@ impl Step for CrateLibrustc {
}
// for (krate, path, _default) in krates("std") {
// rules.test(&krate.test_step, path)
// .dep(|s| s.name("libtest"))
// .dep(|s| s.name("remote-copy-libs"))
// .run(move |s| check::krate(build, &s.compiler(), s.target,
// Mode::Libstd, TestKind::Test,
// Some(&krate.name)));
// }
// rules.test("check-std-all", "path/to/nowhere")
// .dep(|s| s.name("libtest"))
// .dep(|s| s.name("remote-copy-libs"))
// .default(true)
// .run(move |s| check::krate(build, &s.compiler(), s.target,
// Mode::Libstd, TestKind::Test, None));
//
// // std benchmarks
// for (krate, path, _default) in krates("std") {
// rules.bench(&krate.bench_step, path)
// .dep(|s| s.name("libtest"))
// .dep(|s| s.name("remote-copy-libs"))
// .run(move |s| check::krate(build, &s.compiler(), s.target,
// Mode::Libstd, TestKind::Bench,
// Some(&krate.name)));
// }
// rules.bench("bench-std-all", "path/to/nowhere")
// .dep(|s| s.name("libtest"))
// .dep(|s| s.name("remote-copy-libs"))
// .default(true)
// .run(move |s| check::krate(build, &s.compiler(), s.target,
// Mode::Libstd, TestKind::Bench, None));
//
// for (krate, path, _default) in krates("test") {
// rules.test(&krate.test_step, path)
// .dep(|s| s.name("libtest"))
// .dep(|s| s.name("remote-copy-libs"))
// .run(move |s| check::krate(build, &s.compiler(), s.target,
// Mode::Libtest, TestKind::Test,
// Some(&krate.name)));
// }
// rules.test("check-test-all", "path/to/nowhere")
// .dep(|s| s.name("libtest"))
// .dep(|s| s.name("remote-copy-libs"))
// .default(true)
// .run(move |s| check::krate(build, &s.compiler(), s.target,
// Mode::Libtest, TestKind::Test, None));
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct Crate {
compiler: Compiler,
@ -1383,25 +1182,6 @@ fn find_tests(dir: &Path, target: Interned<String>) -> Vec<PathBuf> {
dst
}
// rules.test("remote-copy-libs", "path/to/nowhere")
// .dep(|s| s.name("libtest"))
// .dep(move |s| {
// if build.remote_tested(s.target) {
// s.name("tool-remote-test-client").target(s.host).stage(0)
// } else {
// Step::noop()
// }
// })
// .dep(move |s| {
// if build.remote_tested(s.target) {
// s.name("tool-remote-test-server")
// } else {
// Step::noop()
// }
// })
// .run(move |s| check::remote_copy_libs(build, &s.compiler(), s.target));
//
/// Some test suites are run inside emulators or on remote devices, and most
/// of our test binaries are linked dynamically which means we need to ship
/// the standard library and such to the emulator ahead of time. This step
@ -1464,11 +1244,6 @@ impl Step for RemoteCopyLibs {
}
}
//rules.test("check-distcheck", "distcheck")
// .dep(|s| s.name("dist-plain-source-tarball"))
// .dep(|s| s.name("dist-src"))
// .run(move |_| check::distcheck(build));
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct Distcheck;
@ -1534,12 +1309,6 @@ impl Step for Distcheck {
}
}
//rules.test("check-bootstrap", "src/bootstrap")
// .default(true)
// .host(true)
// .only_build(true)
// .run(move |_| check::bootstrap(build));
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct Bootstrap;

162
src/bootstrap/compile.rs
View file

@ -36,112 +36,6 @@ use native;
use cache::{INTERNER, Interned};
use builder::{Step, ShouldRun, Builder};
//
// // Crates which have build scripts need to rely on this rule to ensure that
// // the necessary prerequisites for a build script are linked and located in
// // place.
// rules.build("may-run-build-script", "path/to/nowhere")
// .dep(move |s| {
// s.name("libstd-link")
// .host(&build.build)
// .target(&build.build)
// });
// // ========================================================================
// // Crate compilations
// //
// // Tools used during the build system but not shipped
// // These rules are "pseudo rules" that don't actually do any work
// // themselves, but represent a complete sysroot with the relevant compiler
// // linked into place.
// //
// // That is, depending on "libstd" means that when the rule is completed then
// // the `stage` sysroot for the compiler `host` will be available with a
// // standard library built for `target` linked in place. Not all rules need
// // the compiler itself to be available, just the standard library, so
// // there's a distinction between the two.
// rules.build("libstd", "src/libstd")
// .dep(|s| s.name("rustc").target(s.host))
// .dep(|s| s.name("libstd-link"));
// rules.build("libtest", "src/libtest")
// .dep(|s| s.name("libstd"))
// .dep(|s| s.name("libtest-link"))
// .default(true);
// rules.build("librustc", "src/librustc")
// .dep(|s| s.name("libtest"))
// .dep(|s| s.name("librustc-link"))
// .host(true)
// .default(true);
// Helper method to define the rules to link a crate into its place in the
// sysroot.
//
// The logic here is a little subtle as there's a few cases to consider.
// Not all combinations of (stage, host, target) actually require something
// to be compiled, but rather libraries could get propagated from a
// different location. For example:
//
// * Any crate with a `host` that's not the build triple will not actually
// compile something. A different `host` means that the build triple will
// actually compile the libraries, and then we'll copy them over from the
// build triple to the `host` directory.
//
// * Some crates aren't even compiled by the build triple, but may be copied
// from previous stages. For example if we're not doing a full bootstrap
// then we may just depend on the stage1 versions of libraries to be
// available to get linked forward.
//
// * Finally, there are some cases, however, which do indeed comiple crates
// and link them into place afterwards.
//
// The rule definition below mirrors these three cases. The `dep` method
// calculates the correct dependency which either comes from stage1, a
// different compiler, or from actually building the crate itself (the `dep`
// rule). The `run` rule then mirrors these three cases and links the cases
// forward into the compiler sysroot specified from the correct location.
// fn crate_rule<'a, 'b>(build: &'a Build,
// rules: &'b mut Rules<'a>,
// krate: &'a str,
// dep: &'a str,
// link: fn(&Build, compiler, compiler, &str))
// -> RuleBuilder<'a, 'b> {
// let mut rule = rules.build(&krate, "path/to/nowhere");
// rule.dep(move |s| {
// if build.force_use_stage1(&s.compiler(), s.target) {
// s.host(&build.build).stage(1)
// } else if s.host == build.build {
// s.name(dep)
// } else {
// s.host(&build.build)
// }
// })
// .run(move |s| {
// if build.force_use_stage1(&s.compiler(), s.target) {
// link(build,
// &s.stage(1).host(&build.build).compiler(),
// &s.compiler(),
// s.target)
// } else if s.host == build.build {
// link(build, &s.compiler(), &s.compiler(), s.target)
// } else {
// link(build,
// &s.host(&build.build).compiler(),
// &s.compiler(),
// s.target)
// }
// });
// rule
// }
// rules.build("libstd", "src/libstd")
// .dep(|s| s.name("rustc").target(s.host))
// .dep(|s| s.name("libstd-link"));
// for (krate, path, _default) in krates("std") {
// rules.build(&krate.build_step, path)
// .dep(|s| s.name("startup-objects"))
// .dep(move |s| s.name("rustc").host(&build.build).target(s.host))
// .run(move |s| compile::std(build, s.target, &s.compiler()));
// }
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct Std {
pub target: Interned<String>,
@ -256,14 +150,6 @@ impl Step for Std {
}
// crate_rule(build,
// &mut rules,
// "libstd-link",
// "build-crate-std",
// compile::std_link)
// .dep(|s| s.name("startup-objects"))
// .dep(|s| s.name("create-sysroot").target(s.host));
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
struct StdLink {
pub compiler: Compiler,
@ -334,10 +220,6 @@ fn copy_apple_sanitizer_dylibs(native_dir: &Path, platform: &str, into: &Path) {
}
}
// rules.build("startup-objects", "src/rtstartup")
// .dep(|s| s.name("create-sysroot").target(s.host))
// .run(move |s| compile::build_startup_objects(build, &s.compiler(), s.target));
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct StartupObjects {
pub compiler: Compiler,
@ -404,11 +286,6 @@ impl Step for StartupObjects {
}
}
// for (krate, path, _default) in krates("test") {
// rules.build(&krate.build_step, path)
// .dep(|s| s.name("libstd-link"))
// .run(move |s| compile::test(build, s.target, &s.compiler()));
// }
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct Test {
pub compiler: Compiler,
@ -484,14 +361,6 @@ impl Step for Test {
}
}
// crate_rule(build,
// &mut rules,
// "libtest-link",
// "build-crate-test",
// compile::test_link)
// .dep(|s| s.name("libstd-link"));
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct TestLink {
pub compiler: Compiler,
@ -523,14 +392,6 @@ impl Step for TestLink {
}
}
// for (krate, path, _default) in krates("rustc-main") {
// rules.build(&krate.build_step, path)
// .dep(|s| s.name("libtest-link"))
// .dep(move |s| s.name("llvm").host(&build.build).stage(0))
// .dep(|s| s.name("may-run-build-script"))
// .run(move |s| compile::rustc(build, s.target, &s.compiler()));
// }
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct Rustc {
pub compiler: Compiler,
@ -675,12 +536,6 @@ impl Step for Rustc {
}
}
// crate_rule(build,
// &mut rules,
// "librustc-link",
// "build-crate-rustc-main",
// compile::rustc_link)
// .dep(|s| s.name("libtest-link"));
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
struct RustcLink {
pub compiler: Compiler,
@ -736,9 +591,6 @@ fn compiler_file(compiler: &Path, file: &str) -> PathBuf {
PathBuf::from(out.trim())
}
// rules.build("create-sysroot", "path/to/nowhere")
// .run(move |s| compile::create_sysroot(build, &s.compiler()));
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct Sysroot {
pub compiler: Compiler,
@ -771,20 +623,6 @@ impl Step for Sysroot {
}
}
// the compiler with no target libraries ready to go
// rules.build("rustc", "src/rustc")
// .dep(|s| s.name("create-sysroot").target(s.host))
// .dep(move |s| {
// if s.stage == 0 {
// Step::noop()
// } else {
// s.name("librustc")
// .host(&build.build)
// .stage(s.stage - 1)
// }
// })
// .run(move |s| compile::assemble_rustc(build, s.stage, s.target));
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct Assemble {
/// The compiler which we will produce in this step. Assemble itself will

110
src/bootstrap/dist.rs
View file

@ -18,14 +18,6 @@
//! out to `rust-installer` still. This may one day be replaced with bits and
//! pieces of `rustup.rs`!
// /// Helper to depend on a stage0 build-only rust-installer tool.
// fn tool_rust_installer<'a>(build: &'a Build, step: &Step<'a>) -> Step<'a> {
// step.name("tool-rust-installer")
// .host(&build.build)
// .target(&build.build)
// .stage(0)
// }
use std::env;
use std::fs::{self, File};
use std::io::{Read, Write};
@ -65,13 +57,6 @@ fn rust_installer(builder: &Builder) -> Command {
builder.tool_cmd(Tool::RustInstaller)
}
// rules.dist("dist-docs", "src/doc")
// .default(true)
// .only_host_build(true)
// .dep(|s| s.name("default:doc"))
// .dep(move |s| tool_rust_installer(build, s))
// .run(move |s| dist::docs(build, s.stage, s.target));
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct Docs {
pub stage: u32,
@ -276,16 +261,6 @@ fn make_win_dist(
}
}
// rules.dist("dist-mingw", "path/to/nowhere")
// .default(true)
// .only_host_build(true)
// .dep(move |s| tool_rust_installer(build, s))
// .run(move |s| {
// if s.target.contains("pc-windows-gnu") {
// dist::mingw(build, s.target)
// }
// });
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct Mingw {
target: Interned<String>,
@ -347,14 +322,6 @@ impl Step for Mingw {
}
}
// rules.dist("dist-rustc", "src/librustc")
// .dep(move |s| s.name("rustc").host(&build.build))
// .host(true)
// .only_host_build(true)
// .default(true)
// .dep(move |s| tool_rust_installer(build, s))
// .run(move |s| dist::rustc(build, s.stage, s.target));
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct Rustc {
pub stage: u32,
@ -495,10 +462,6 @@ impl Step for Rustc {
}
}
//rules.test("debugger-scripts", "src/etc/lldb_batchmode.py")
// .run(move |s| dist::debugger_scripts(build, &builder.sysroot(&s.compiler()),
// s.target));
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct DebuggerScripts {
pub sysroot: Interned<PathBuf>,
@ -557,22 +520,6 @@ impl Step for DebuggerScripts {
}
}
// rules.dist("dist-std", "src/libstd")
// .dep(move |s| {
// // We want to package up as many target libraries as possible
// // for the `rust-std` package, so if this is a host target we
// // depend on librustc and otherwise we just depend on libtest.
// if build.config.host.iter().any(|t| t == s.target) {
// s.name("librustc-link")
// } else {
// s.name("libtest-link")
// }
// })
// .default(true)
// .only_host_build(true)
// .dep(move |s| tool_rust_installer(build, s))
// .run(move |s| dist::std(build, &s.compiler(), s.target));
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct Std {
pub compiler: Compiler,
@ -648,13 +595,6 @@ impl Step for Std {
}
}
// rules.dist("dist-analysis", "analysis")
// .default(build.config.extended)
// .dep(|s| s.name("dist-std"))
// .only_host_build(true)
// .dep(move |s| tool_rust_installer(build, s))
// .run(move |s| dist::analysis(build, &s.compiler(), s.target));
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct Analysis {
pub compiler: Compiler,
@ -775,14 +715,6 @@ fn copy_src_dirs(build: &Build, src_dirs: &[&str], exclude_dirs: &[&str], dst_di
}
}
// rules.dist("dist-src", "src")
// .default(true)
// .host(true)
// .only_build(true)
// .only_host_build(true)
// .dep(move |s| tool_rust_installer(build, s))
// .run(move |_| dist::rust_src(build));
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct Src;
@ -874,14 +806,6 @@ impl Step for Src {
const CARGO_VENDOR_VERSION: &str = "0.1.4";
// rules.dist("dist-plain-source-tarball", "src")
// .default(build.config.rust_dist_src)
// .host(true)
// .only_build(true)
// .only_host_build(true)
// .dep(move |s| tool_rust_installer(build, s))
// .run(move |_| dist::plain_source_tarball(build));
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct PlainSourceTarball;
@ -1028,13 +952,6 @@ fn write_file(path: &Path, data: &[u8]) {
t!(vf.write_all(data));
}
// rules.dist("dist-cargo", "cargo")
// .host(true)
// .only_host_build(true)
// .dep(|s| s.name("tool-cargo"))
// .dep(move |s| tool_rust_installer(build, s))
// .run(move |s| dist::cargo(build, s.stage, s.target));
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct Cargo {
pub stage: u32,
@ -1127,12 +1044,6 @@ impl Step for Cargo {
}
}
// rules.dist("dist-rls", "rls")
// .host(true)
// .only_host_build(true)
// .dep(|s| s.name("tool-rls"))
// .dep(move |s| tool_rust_installer(build, s))
// .run(move |s| dist::rls(build, s.stage, s.target));
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct Rls {
pub stage: u32,
@ -1214,20 +1125,6 @@ impl Step for Rls {
}
}
// rules.dist("dist-extended", "extended")
// .default(build.config.extended)
// .host(true)
// .only_host_build(true)
// .dep(|d| d.name("dist-std"))
// .dep(|d| d.name("dist-rustc"))
// .dep(|d| d.name("dist-mingw"))
// .dep(|d| d.name("dist-docs"))
// .dep(|d| d.name("dist-cargo"))
// .dep(|d| d.name("dist-rls"))
// .dep(|d| d.name("dist-analysis"))
// .dep(move |s| tool_rust_installer(build, s))
// .run(move |s| dist::extended(build, s.stage, s.target));
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct Extended {
stage: u32,
@ -1632,13 +1529,6 @@ fn add_env(build: &Build, cmd: &mut Command, target: Interned<String>) {
}
}
// rules.dist("dist-sign", "hash-and-sign")
// .host(true)
// .only_build(true)
// .only_host_build(true)
// .dep(move |s| s.name("tool-build-manifest").target(&build.build).stage(0))
// .run(move |_| dist::hash_and_sign(build));
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct HashSign;

97
src/bootstrap/doc.rs
View file

@ -76,25 +76,7 @@ macro_rules! book {
}
book!(
// rules.doc("doc-nomicon", "src/doc/nomicon")
// .dep(move |s| {
// s.name("tool-rustbook")
// .host(&build.build)
// .target(&build.build)
// .stage(0)
// })
// .default(build.config.docs)
// .run(move |s| doc::rustbook(build, s.target, "nomicon"));
Nomicon, "src/doc/book", "nomicon";
// rules.doc("doc-reference", "src/doc/reference")
// .dep(move |s| {
// s.name("tool-rustbook")
// .host(&build.build)
// .target(&build.build)
// .stage(0)
// })
// .default(build.config.docs)
// .run(move |s| doc::rustbook(build, s.target, "reference"));
Reference, "src/doc/reference", "reference";
);
@ -127,19 +109,6 @@ impl Step for Rustbook {
}
}
//rules.doc("doc-unstable-book", "src/doc/unstable-book")
// .dep(move |s| {
// s.name("tool-rustbook")
// .host(&build.build)
// .target(&build.build)
// .stage(0)
// })
// .dep(move |s| s.name("doc-unstable-book-gen"))
// .default(build.config.docs)
// .run(move |s| doc::rustbook_src(build,
// s.target,
// "unstable-book",
// &build.md_doc_out(s.target)));
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct UnstableBook {
target: Interned<String>,
@ -221,16 +190,6 @@ impl Step for RustbookSrc {
}
}
// rules.doc("doc-book", "src/doc/book")
// .dep(move |s| {
// s.name("tool-rustbook")
// .host(&build.build)
// .target(&build.build)
// .stage(0)
// })
// .default(build.config.docs)
// .run(move |s| doc::book(build, s.target, "book"));
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct TheBook {
target: Interned<String>,
@ -346,16 +305,6 @@ fn invoke_rustdoc(builder: &Builder, target: Interned<String>, markdown: &str) {
build.run(&mut cmd);
}
// rules.doc("doc-standalone", "src/doc")
// .dep(move |s| {
// s.name("rustc")
// .host(&build.build)
// .target(&build.build)
// .stage(0)
// })
// .default(build.config.docs)
// .run(move |s| doc::standalone(build, s.target));
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct Standalone {
target: Interned<String>,
@ -457,13 +406,6 @@ impl Step for Standalone {
}
}
// for (krate, path, default) in krates("std") {
// rules.doc(&krate.doc_step, path)
// .dep(|s| s.name("libstd-link"))
// .default(default && build.config.docs)
// .run(move |s| doc::std(build, s.stage, s.target));
// }
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct Std {
stage: u32,
@ -567,15 +509,6 @@ impl Step for Std {
}
}
// for (krate, path, default) in krates("test") {
// rules.doc(&krate.doc_step, path)
// .dep(|s| s.name("libtest-link"))
// // Needed so rustdoc generates relative links to std.
// .dep(|s| s.name("doc-crate-std"))
// .default(default && build.config.compiler_docs)
// .run(move |s| doc::test(build, s.stage, s.target));
// }
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct Test {
stage: u32,
@ -652,17 +585,6 @@ impl Step for Test {
}
}
// for (krate, path, default) in krates("rustc-main") {
// rules.doc(&krate.doc_step, path)
// .dep(|s| s.name("librustc-link"))
// // Needed so rustdoc generates relative links to std.
// .dep(|s| s.name("doc-crate-std"))
// .host(true)
// .default(default && build.config.docs)
// .run(move |s| doc::rustc(build, s.stage, s.target));
// }
//
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct Rustc {
stage: u32,
@ -757,13 +679,6 @@ impl Step for Rustc {
}
}
// rules.doc("doc-error-index", "src/tools/error_index_generator")
// .dep(move |s| s.name("tool-error-index").target(&build.build).stage(0))
// .dep(move |s| s.name("librustc-link"))
// .default(build.config.docs)
// .host(true)
// .run(move |s| doc::error_index(build, s.target));
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ErrorIndex {
target: Interned<String>,
@ -816,18 +731,6 @@ impl Step for ErrorIndex {
}
}
// rules.doc("doc-unstable-book-gen", "src/tools/unstable-book-gen")
// .dep(move |s| {
// s.name("tool-unstable-book-gen")
// .host(&build.build)
// .target(&build.build)
// .stage(0)
// })
// .dep(move |s| s.name("libstd-link"))
// .default(build.config.docs)
// .host(true)
// .run(move |s| doc::unstable_book_gen(build, s.target));
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct UnstableBookGen {
target: Interned<String>,

40
src/bootstrap/install.rs
View file

@ -177,20 +177,10 @@ macro_rules! install {
}
install!((self, builder),
// rules.install("install-docs", "src/doc")
// .default(build.config.docs)
// .only_host_build(true)
// .dep(|s| s.name("dist-docs"))
// .run(move |s| install::Installer::new(build).install_docs(s.stage, s.target));
Docs, "src/doc", builder.build.config.docs, only_hosts: false, {
builder.ensure(dist::Docs { stage: self.stage, target: self.target });
install_docs(builder, self.stage, self.target);
};
// rules.install("install-std", "src/libstd")
// .default(true)
// .only_host_build(true)
// .dep(|s| s.name("dist-std"))
// .run(move |s| install::Installer::new(build).install_std(s.stage));
Std, "src/libstd", true, only_hosts: true, {
builder.ensure(dist::Std {
compiler: builder.compiler(self.stage, self.host),
@ -198,31 +188,14 @@ install!((self, builder),
});
install_std(builder, self.stage);
};
// rules.install("install-cargo", "cargo")
// .default(build.config.extended)
// .host(true)
// .only_host_build(true)
// .dep(|s| s.name("dist-cargo"))
// .run(move |s| install::Installer::new(build).install_cargo(s.stage, s.target));
Cargo, "cargo", builder.build.config.extended, only_hosts: true, {
builder.ensure(dist::Cargo { stage: self.stage, target: self.target });
install_cargo(builder, self.stage, self.target);
};
// rules.install("install-rls", "rls")
// .default(build.config.extended)
// .host(true)
// .only_host_build(true)
// .dep(|s| s.name("dist-rls"))
// .run(move |s| install::Installer::new(build).install_rls(s.stage, s.target));
Rls, "rls", builder.build.config.extended, only_hosts: true, {
builder.ensure(dist::Rls { stage: self.stage, target: self.target });
install_rls(builder, self.stage, self.target);
};
// rules.install("install-analysis", "analysis")
// .default(build.config.extended)
// .only_host_build(true)
// .dep(|s| s.name("dist-analysis"))
// .run(move |s| install::Installer::new(build).install_analysis(s.stage, s.target));
Analysis, "analysis", builder.build.config.extended, only_hosts: false, {
builder.ensure(dist::Analysis {
compiler: builder.compiler(self.stage, self.host),
@ -230,23 +203,10 @@ install!((self, builder),
});
install_analysis(builder, self.stage, self.target);
};
// rules.install("install-src", "src")
// .default(build.config.extended)
// .host(true)
// .only_build(true)
// .only_host_build(true)
// .dep(|s| s.name("dist-src"))
// .run(move |s| install::Installer::new(build).install_src(s.stage));
Src, "src", builder.build.config.extended, only_hosts: true, {
builder.ensure(dist::Src);
install_src(builder, self.stage);
}, ONLY_BUILD;
// rules.install("install-rustc", "src/librustc")
// .default(true)
// .host(true)
// .only_host_build(true)
// .dep(|s| s.name("dist-rustc"))
// .run(move |s| install::Installer::new(build).install_rustc(s.stage, s.target));
Rustc, "src/librustc", builder.build.config.extended, only_hosts: true, {
builder.ensure(dist::Rustc { stage: self.stage, target: self.target });
install_rustc(builder, self.stage, self.target);

19
src/bootstrap/native.rs
View file

@ -35,17 +35,6 @@ use build_helper::up_to_date;
use builder::{Builder, ShouldRun, Step};
use cache::Interned;
// rules.build("llvm", "src/llvm")
// .host(true)
// .dep(move |s| {
// if s.target == build.build {
// Step::noop()
// } else {
// s.target(&build.build)
// }
// })
// .run(move |s| native::llvm(build, s.target));
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct Llvm {
pub target: Interned<String>,
@ -246,9 +235,6 @@ fn check_llvm_version(build: &Build, llvm_config: &Path) {
panic!("\n\nbad LLVM version: {}, need >=3.5\n\n", version)
}
//rules.build("test-helpers", "src/rt/rust_test_helpers.c")
// .run(move |s| native::test_helpers(build, s.target));
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct TestHelpers {
pub target: Interned<String>,
@ -311,10 +297,7 @@ const OPENSSL_VERS: &'static str = "1.0.2k";
const OPENSSL_SHA256: &'static str =
"6b3977c61f2aedf0f96367dcfb5c6e578cf37e7b8d913b4ecb6643c3cb88d8c0";
//rules.build("openssl", "path/to/nowhere")
// .run(move |s| native::openssl(build, s.target));
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct Openssl {
pub target: Interned<String>,
}

91
src/bootstrap/tool.rs
View file

@ -21,30 +21,6 @@ use native;
use channel::GitInfo;
use cache::Interned;
//// ========================================================================
//// Build tools
////
//// Tools used during the build system but not shipped
//// "pseudo rule" which represents completely cleaning out the tools dir in
//// one stage. This needs to happen whenever a dependency changes (e.g.
//// libstd, libtest, librustc) and all of the tool compilations above will
//// be sequenced after this rule.
//rules.build("maybe-clean-tools", "path/to/nowhere")
// .after("librustc-tool")
// .after("libtest-tool")
// .after("libstd-tool");
//
//rules.build("librustc-tool", "path/to/nowhere")
// .dep(|s| s.name("librustc"))
// .run(move |s| compile::maybe_clean_tools(build, s.stage, s.target, Mode::Librustc));
//rules.build("libtest-tool", "path/to/nowhere")
// .dep(|s| s.name("libtest"))
// .run(move |s| compile::maybe_clean_tools(build, s.stage, s.target, Mode::Libtest));
//rules.build("libstd-tool", "path/to/nowhere")
// .dep(|s| s.name("libstd"))
// .run(move |s| compile::maybe_clean_tools(build, s.stage, s.target, Mode::Libstd));
//
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct CleanTools {
pub stage: u32,
@ -213,55 +189,15 @@ macro_rules! tool {
}
tool!(
// rules.build("tool-rustbook", "src/tools/rustbook")
// .dep(|s| s.name("maybe-clean-tools"))
// .dep(|s| s.name("librustc-tool"))
// .run(move |s| compile::tool(build, s.stage, s.target, "rustbook"));
Rustbook, "src/tools/rustbook", "rustbook", Mode::Librustc;
// rules.build("tool-error-index", "src/tools/error_index_generator")
// .dep(|s| s.name("maybe-clean-tools"))
// .dep(|s| s.name("librustc-tool"))
// .run(move |s| compile::tool(build, s.stage, s.target, "error_index_generator"));
ErrorIndex, "src/tools/error_index_generator", "error_index_generator", Mode::Librustc;
// rules.build("tool-unstable-book-gen", "src/tools/unstable-book-gen")
// .dep(|s| s.name("maybe-clean-tools"))
// .dep(|s| s.name("libstd-tool"))
// .run(move |s| compile::tool(build, s.stage, s.target, "unstable-book-gen"));
UnstableBookGen, "src/tools/unstable-book-gen", "unstable-book-gen", Mode::Libstd;
// rules.build("tool-tidy", "src/tools/tidy")
// .dep(|s| s.name("maybe-clean-tools"))
// .dep(|s| s.name("libstd-tool"))
// .run(move |s| compile::tool(build, s.stage, s.target, "tidy"));
Tidy, "src/tools/tidy", "tidy", Mode::Libstd;
// rules.build("tool-linkchecker", "src/tools/linkchecker")
// .dep(|s| s.name("maybe-clean-tools"))
// .dep(|s| s.name("libstd-tool"))
// .run(move |s| compile::tool(build, s.stage, s.target, "linkchecker"));
Linkchecker, "src/tools/linkchecker", "linkchecker", Mode::Libstd;
// rules.build("tool-cargotest", "src/tools/cargotest")
// .dep(|s| s.name("maybe-clean-tools"))
// .dep(|s| s.name("libstd-tool"))
// .run(move |s| compile::tool(build, s.stage, s.target, "cargotest"));
CargoTest, "src/tools/cargotest", "cargotest", Mode::Libstd;
// rules.build("tool-compiletest", "src/tools/compiletest")
// .dep(|s| s.name("maybe-clean-tools"))
// .dep(|s| s.name("libtest-tool"))
// .run(move |s| compile::tool(build, s.stage, s.target, "compiletest"));
Compiletest, "src/tools/compiletest", "compiletest", Mode::Libtest;
// rules.build("tool-build-manifest", "src/tools/build-manifest")
// .dep(|s| s.name("maybe-clean-tools"))
// .dep(|s| s.name("libstd-tool"))
// .run(move |s| compile::tool(build, s.stage, s.target, "build-manifest"));
BuildManifest, "src/tools/build-manifest", "build-manifest", Mode::Librustc;
// rules.build("tool-remote-test-client", "src/tools/remote-test-client")
// .dep(|s| s.name("maybe-clean-tools"))
// .dep(|s| s.name("libstd-tool"))
// .run(move |s| compile::tool(build, s.stage, s.target, "remote-test-client"));
RemoteTestClient, "src/tools/remote-test-client", "remote-test-client", Mode::Libstd;
// rules.build("tool-rust-installer", "src/tools/rust-installer")
// .dep(|s| s.name("maybe-clean-tools"))
// .dep(|s| s.name("libstd-tool"))
// .run(move |s| compile::tool(build, s.stage, s.target, "rust-installer"));
RustInstaller, "src/tools/rust-installer", "rust-installer", Mode::Libstd;
);
@ -300,20 +236,6 @@ impl Step for RemoteTestServer {
}
}
// rules.build("tool-cargo", "src/tools/cargo")
// .host(true)
// .default(build.config.extended)
// .dep(|s| s.name("maybe-clean-tools"))
// .dep(|s| s.name("libstd-tool"))
// .dep(|s| s.stage(0).host(s.target).name("openssl"))
// .dep(move |s| {
// // Cargo depends on procedural macros, which requires a full host
// // compiler to be available, so we need to depend on that.
// s.name("librustc-link")
// .target(&build.build)
// .host(&build.build)
// })
// .run(move |s| compile::tool(build, s.stage, s.target, "cargo"));
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct Cargo {
pub stage: u32,
@ -360,19 +282,6 @@ impl Step for Cargo {
}
}
// rules.build("tool-rls", "src/tools/rls")
// .host(true)
// .default(build.config.extended)
// .dep(|s| s.name("librustc-tool"))
// .dep(|s| s.stage(0).host(s.target).name("openssl"))
// .dep(move |s| {
// // rls, like cargo, uses procedural macros
// s.name("librustc-link")
// .target(&build.build)
// .host(&build.build)
// })
// .run(move |s| compile::tool(build, s.stage, s.target, "rls"));
//
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct Rls {
pub stage: u32,