Change code to work with the new system

Author: Mark-Simulacrum

src/bootstrap/check.rs

@@ -129,6 +129,9 @@ fn crate_rule<'a, 'b>(build: &'a Build,
         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"))
@@ -143,6 +146,21 @@ pub struct Std<'a> {
 
 impl<'a> Step<'a> for Std<'a> {
     type Output = ();
+    const DEFAULT: bool = true;
+
+    fn should_run(builder: &Builder, path: &Path) -> bool {
+        path.ends_with("src/libstd") ||
+        builder.crates("std").into_iter().any(|(_, krate_path)| {
+            path.ends_with(krate_path)
+        })
+    }
+
+    fn make_run(builder: &Builder, _path: Option<&Path>, host: &str, target: &str) {
+        builder.ensure(Std {
+            compiler: builder.compiler(builder.top_stage, host),
+            target,
+        })
+    }
 
     /// Build the standard library.
     ///
@@ -153,16 +171,31 @@ impl<'a> Step<'a> for Std<'a> {
         let build = builder.build;
         let target = self.target;
         let compiler = self.compiler;
-        let libdir = build.sysroot_libdir(compiler, target);
-        t!(fs::create_dir_all(&libdir));
+
+        builder.ensure(StartupObjects { compiler, target });
+
+        if build.force_use_stage1(compiler, target) {
+            let from = builder.compiler(1, &build.build);
+            builder.ensure(Std {
+                compiler: from,
+                target: target,
+            });
+            println!("Uplifting stage1 std ({} -> {})", from.host, target);
+            builder.ensure(StdLink {
+                compiler: from,
+                target_compiler: compiler,
+                target: target,
+            });
+            return;
+        }
 
         let _folder = build.fold_output(|| format!("stage{}-std", compiler.stage));
         println!("Building stage{} std artifacts ({} -> {})", compiler.stage,
                 compiler.host, target);
 
         let out_dir = build.cargo_out(compiler, Mode::Libstd, target);
         build.clear_if_dirty(&out_dir, &build.compiler_path(compiler));
-        let mut cargo = build.cargo(compiler, Mode::Libstd, target, "build");
+        let mut cargo = builder.cargo(compiler, Mode::Libstd, target, "build");
         let mut features = build.std_features();
 
         if let Some(target) = env::var_os("MACOSX_STD_DEPLOYMENT_TARGET") {
@@ -188,6 +221,7 @@ impl<'a> Step<'a> for Std<'a> {
             // config.toml equivalent) is used
             cargo.env("LLVM_CONFIG", build.llvm_config(target));
         }
+
         cargo.arg("--features").arg(features)
             .arg("--manifest-path")
             .arg(build.src.join("src/libstd/Cargo.toml"));
@@ -206,6 +240,12 @@ impl<'a> Step<'a> for Std<'a> {
         run_cargo(build,
                 &mut cargo,
                 &libstd_stamp(build, &compiler, target));
+
+        builder.ensure(StdLink {
+            compiler: builder.compiler(compiler.stage, &build.build),
+            target_compiler: compiler,
+            target: target,
+        });
     }
 }
 
@@ -219,7 +259,7 @@ impl<'a> Step<'a> for Std<'a> {
 //     .dep(|s| s.name("create-sysroot").target(s.host));
 
 #[derive(Serialize)]
-pub struct StdLink<'a> {
+struct StdLink<'a> {
     pub compiler: Compiler<'a>,
     pub target_compiler: Compiler<'a>,
     pub target: &'a str,
@@ -297,6 +337,17 @@ pub struct StartupObjects<'a> {
 impl<'a> Step<'a> for StartupObjects<'a> {
     type Output = ();
 
+    fn should_run(_builder: &Builder, path: &Path) -> bool {
+        path.ends_with("src/rtstartup")
+    }
+
+    fn make_run(builder: &Builder, _path: Option<&Path>, host: &str, target: &str) {
+        builder.ensure(StartupObjects {
+            compiler: builder.compiler(builder.top_stage, host),
+            target,
+        })
+    }
+
     /// Build and prepare startup objects like rsbegin.o and rsend.o
     ///
     /// These are primarily used on Windows right now for linking executables/dlls.
@@ -354,6 +405,21 @@ pub struct Test<'a> {
 
 impl<'a> Step<'a> for Test<'a> {
     type Output = ();
+    const DEFAULT: bool = true;
+
+    fn should_run(builder: &Builder, path: &Path) -> bool {
+        path.ends_with("src/libtest") ||
+        builder.crates("test").into_iter().any(|(_, krate_path)| {
+            path.ends_with(krate_path)
+        })
+    }
+
+    fn make_run(builder: &Builder, _path: Option<&Path>, host: &str, target: &str) {
+        builder.ensure(Test {
+            compiler: builder.compiler(builder.top_stage, host),
+            target,
+        })
+    }
 
     /// Build libtest.
     ///
@@ -364,6 +430,23 @@ impl<'a> Step<'a> for Test<'a> {
         let build = builder.build;
         let target = self.target;
         let compiler = self.compiler;
+
+        builder.ensure(Std { compiler, target });
+
+        if build.force_use_stage1(compiler, target) {
+            builder.ensure(Test {
+                compiler: builder.compiler(1, &build.build),
+                target: target,
+            });
+            println!("Uplifting stage1 test ({} -> {})", &build.build, target);
+            builder.ensure(TestLink {
+                compiler: builder.compiler(1, &build.build),
+                target_compiler: compiler,
+                target: target,
+            });
+            return;
+        }
+
         let _folder = build.fold_output(|| format!("stage{}-test", compiler.stage));
         println!("Building stage{} test artifacts ({} -> {})", compiler.stage,
                 compiler.host, target);
@@ -378,6 +461,12 @@ impl<'a> Step<'a> for Test<'a> {
         run_cargo(build,
                 &mut cargo,
                 &libtest_stamp(build, compiler, target));
+
+        builder.ensure(TestLink {
+            compiler: builder.compiler(1, &build.build),
+            target_compiler: compiler,
+            target: target,
+        });
     }
 }
 
@@ -432,6 +521,22 @@ pub struct Rustc<'a> {
 
 impl<'a> Step<'a> for Rustc<'a> {
     type Output = ();
+    const ONLY_HOSTS: bool = true;
+    const DEFAULT: bool = true;
+
+    fn should_run(builder: &Builder, path: &Path) -> bool {
+        path.ends_with("src/librustc") ||
+        builder.crates("rustc-main").into_iter().any(|(_, krate_path)| {
+            path.ends_with(krate_path)
+        })
+    }
+
+    fn make_run(builder: &Builder, _path: Option<&Path>, host: &str, target: &str) {
+        builder.ensure(Rustc {
+            compiler: builder.compiler(builder.top_stage, host),
+            target,
+        })
+    }
 
     /// Build the compiler.
     ///
@@ -442,6 +547,33 @@ impl<'a> Step<'a> for Rustc<'a> {
         let build = builder.build;
         let compiler = self.compiler;
         let target = self.target;
+
+        builder.ensure(Test { compiler, target });
+
+        // Build LLVM for our target. This will implicitly build the host LLVM
+        // if necessary.
+        builder.ensure(native::Llvm { target });
+
+        if build.force_use_stage1(compiler, target) {
+            builder.ensure(Rustc {
+                compiler: builder.compiler(1, &build.build),
+                target: target,
+            });
+            println!("Uplifting stage1 rustc ({} -> {})", &build.build, target);
+            builder.ensure(RustcLink {
+                compiler: builder.compiler(1, &build.build),
+                target_compiler: compiler,
+                target,
+            });
+            return;
+        }
+
+        // Ensure that build scripts have a std to link against.
+        builder.ensure(Std {
+            compiler: builder.compiler(self.compiler.stage, &build.build),
+            target: &build.build,
+        });
+
         let _folder = build.fold_output(|| format!("stage{}-rustc", compiler.stage));
         println!("Building stage{} compiler artifacts ({} -> {})",
                  compiler.stage, compiler.host, target);
@@ -513,6 +645,12 @@ impl<'a> Step<'a> for Rustc<'a> {
         run_cargo(build,
                   &mut cargo,
                   &librustc_stamp(build, compiler, target));
+
+        builder.ensure(RustcLink {
+            compiler: builder.compiler(compiler.stage, &build.build),
+            target_compiler: compiler,
+            target,
+        });
     }
 }
 
@@ -523,7 +661,7 @@ impl<'a> Step<'a> for Rustc<'a> {
 //            compile::rustc_link)
 //     .dep(|s| s.name("libtest-link"));
 #[derive(Serialize)]
-pub struct RustcLink<'a> {
+struct RustcLink<'a> {
     pub compiler: Compiler<'a>,
     pub target_compiler: Compiler<'a>,
     pub target: &'a str,
@@ -551,19 +689,19 @@ impl<'a> Step<'a> for RustcLink<'a> {
 
 /// Cargo's output path for the standard library in a given stage, compiled
 /// by a particular compiler for the specified target.
-fn libstd_stamp(build: &Build, compiler: &Compiler, target: &str) -> PathBuf {
+pub fn libstd_stamp(build: &Build, compiler: &Compiler, target: &str) -> PathBuf {
     build.cargo_out(compiler, Mode::Libstd, target).join(".libstd.stamp")
 }
 
 /// Cargo's output path for libtest in a given stage, compiled by a particular
 /// compiler for the specified target.
-fn libtest_stamp(build: &Build, compiler: &Compiler, target: &str) -> PathBuf {
+pub fn libtest_stamp(build: &Build, compiler: &Compiler, target: &str) -> PathBuf {
     build.cargo_out(compiler, Mode::Libtest, target).join(".libtest.stamp")
 }
 
 /// Cargo's output path for librustc in a given stage, compiled by a particular
 /// compiler for the specified target.
-fn librustc_stamp(build: &Build, compiler: &Compiler, target: &str) -> PathBuf {
+pub fn librustc_stamp(build: &Build, compiler: &Compiler, target: &str) -> PathBuf {
     build.cargo_out(compiler, Mode::Librustc, target).join(".librustc.stamp")
 }
 
@@ -582,20 +720,25 @@ pub struct Sysroot<'a> {
 }
 
 impl<'a> Step<'a> for Sysroot<'a> {
-    type Output = ();
+    type Output = PathBuf;
 
     /// Returns the sysroot for the `compiler` specified that *this build system
     /// generates*.
     ///
     /// That is, the sysroot for the stage0 compiler is not what the compiler
     /// thinks it is by default, but it's the same as the default for stages
     /// 1-3.
-    fn run(self, builder: &Builder) {
+    fn run(self, builder: &Builder) -> PathBuf {
         let build = builder.build;
         let compiler = self.compiler;
-        let sysroot = build.sysroot(compiler);
+        let sysroot = if compiler.stage == 0 {
+            build.out.join(compiler.host).join("stage0-sysroot")
+        } else {
+            build.out.join(compiler.host).join(format!("stage{}", compiler.stage))
+        };
         let _ = fs::remove_dir_all(&sysroot);
         t!(fs::create_dir_all(&sysroot));
+        sysroot
     }
 }
 
@@ -615,8 +758,11 @@ impl<'a> Step<'a> for Sysroot<'a> {
 
 #[derive(Serialize)]
 pub struct Assemble<'a> {
-    pub stage: u32,
-    pub host: &'a str,
+    /// The compiler which we will produce in this step. Assemble itself will
+    /// take care of ensuring that the necessary prerequisites to do so exist,
+    /// that is, this target can be a stage2 compiler and Assemble will build
+    /// previous stages for you.
+    pub target_compiler: Compiler<'a>,
 }
 
 impl<'a> Step<'a> for Assemble<'a> {
@@ -629,20 +775,48 @@ impl<'a> Step<'a> for Assemble<'a> {
     /// compiler.
     fn run(self, builder: &Builder) {
         let build = builder.build;
-        let stage = self.stage;
-        let host = self.host;
-        // nothing to do in stage0
-        if stage == 0 {
-            return
+        let target_compiler = self.target_compiler;
+
+        if target_compiler.stage == 0 {
+            assert_eq!(build.build, target_compiler.host,
+                "Cannot obtain compiler for non-native build triple at stage 0");
+            // The stage 0 compiler for the build triple is always pre-built.
+            return target_compiler;
         }
 
-        println!("Copying stage{} compiler ({})", stage, host);
+        // Get the compiler that we'll use to bootstrap ourselves.
+        let build_compiler = if target_compiler.host != build.build {
+            // Build a compiler for the host platform. We cannot use the stage0
+            // compiler for the host platform for this because it doesn't have
+            // the libraries we need.  FIXME: Perhaps we should download those
+            // libraries? It would make builds faster...
+            builder.ensure(Assemble {
+                target_compiler: Compiler {
+                    // FIXME: It may be faster if we build just a stage 1
+                    // compiler and then use that to bootstrap this compiler
+                    // forward.
+                    stage: target_compiler.stage - 1,
+                    host: &build.build
+                },
+            })
+        } else {
+            // Build the compiler we'll use to build the stage requested. This
+            // may build more than one compiler (going down to stage 0).
+            builder.ensure(Assemble {
+                target_compiler: target_compiler.with_stage(target_compiler.stage - 1),
+            })
+        };
 
-        // The compiler that we're assembling
-        let target_compiler = Compiler::new(stage, host);
+        // Build the libraries for this compiler to link to (i.e., the libraries
+        // it uses at runtime). NOTE: Crates the target compiler compiles don't
+        // link to these. (FIXME: Is that correct? It seems to be correct most
+        // of the time but I think we do link to these for stage2/bin compilers
+        // when not performing a full bootstrap).
+        builder.ensure(Rustc { compiler: build_compiler, target: target_compiler.host });
 
-        // The compiler that compiled the compiler we're assembling
-        let build_compiler = Compiler::new(stage - 1, &build.build);
+        let stage = target_compiler.stage;
+        let host = target_compiler.host;
+        println!("Assembling stage{} compiler ({})", stage, host);
 
         // Link in all dylibs to the libdir
         let sysroot = build.sysroot(&target_compiler);

src/bootstrap/compile.rs

@@ -76,6 +76,19 @@ pub struct Docs<'a> {
 
 impl<'a> Step<'a> for Docs<'a> {
     type Output = ();
+    const DEFAULT: bool = true;
+    const ONLY_BUILD_TARGETS: bool = true;
+
+    fn should_run(_builder: &Builder, path: &Path) -> bool {
+        path.ends_with("src/doc")
+    }
+
+    fn make_run(builder: &Builder, _path: Option<&Path>, _host: &str, target: &str) {
+        builder.ensure(Docs {
+            stage: builder.top_stage,
+            host: target,
+        });
+    }
 
     /// Builds the `rust-docs` installer component.
     ///
@@ -85,6 +98,8 @@ impl<'a> Step<'a> for Docs<'a> {
         let stage = self.stage;
         let host = self.host;
 
+        builder.default_doc(None);
+
         println!("Dist docs stage{} ({})", stage, host);
         if !build.config.docs {
             println!("\tskipping - docs disabled");
@@ -268,6 +283,18 @@ pub struct Mingw<'a> {
 
 impl<'a> Step<'a> for Mingw<'a> {
     type Output = ();
+    const DEFAULT: bool = true;
+    const ONLY_BUILD_TARGETS: bool = true;
+
+    fn should_run(_builder: &Builder, _path: &Path) -> bool {
+        false
+    }
+
+    fn make_run(builder: &Builder, _path: Option<&Path>, host: &str, _target: &str) {
+        builder.ensure(Mingw {
+            host: host,
+        });
+    }
 
     /// Build the `rust-mingw` installer component.
     ///
@@ -276,6 +303,11 @@ impl<'a> Step<'a> for Mingw<'a> {
     fn run(self, builder: &Builder) {
         let build = builder.build;
         let host = self.host;
+
+        if !host.contains("pc-windows-gnu") {
+            return;
+        }
+
         println!("Dist mingw ({})", host);
         let name = pkgname(build, "rust-mingw");
         let image = tmpdir(build).join(format!("{}-{}-image", name, host));
@@ -320,6 +352,20 @@ pub struct Rustc<'a> {
 
 impl<'a> Step<'a> for Rustc<'a> {
     type Output = ();
+    const DEFAULT: bool = true;
+    const ONLY_HOSTS: bool = true;
+    const ONLY_BUILD_TARGETS: bool = true;
+
+    fn should_run(_builder: &Builder, path: &Path) -> bool {
+        path.ends_with("src/librustc")
+    }
+
+    fn make_run(builder: &Builder, _path: Option<&Path>, host: &str, _target: &str) {
+        builder.ensure(Rustc {
+            stage: builder.top_stage,
+            host: host,
+        });
+    }
 
     /// Creates the `rustc` installer component.
     fn run(self, builder: &builder) {
@@ -334,7 +380,7 @@ impl<'a> Step<'a> for Rustc<'a> {
         let _ = fs::remove_dir_all(&overlay);
 
         // Prepare the rustc "image", what will actually end up getting installed
-        prepare_image(build, stage, host, &image);
+        prepare_image(builder, stage, host, &image);
 
         // Prepare the overlay which is part of the tarball but won't actually be
         // installed
@@ -384,8 +430,9 @@ impl<'a> Step<'a> for Rustc<'a> {
         t!(fs::remove_dir_all(&image));
         t!(fs::remove_dir_all(&overlay));
 
-        fn prepare_image(build: &Build, stage: u32, host: &str, image: &Path) {
-            let src = build.sysroot(&Compiler::new(stage, host));
+        fn prepare_image(builder: &Builder, stage: u32, host: &str, image: &Path) {
+            let build = builder.build;
+            let src = build.sysroot(builder.compiler(stage, host));
             let libdir = libdir(host);
 
             // Copy rustc/rustdoc binaries
@@ -409,7 +456,10 @@ impl<'a> Step<'a> for Rustc<'a> {
             cp_r(&build.src.join("man"), &image.join("share/man/man1"));
 
             // Debugger scripts
-            debugger_scripts(build, &image, host);
+            builder.ensure(DebuggerScripts {
+                sysroot: &image,
+                host: host,
+            });
 
             // Misc license info
             let cp = |file: &str| {
@@ -423,8 +473,6 @@ impl<'a> Step<'a> for Rustc<'a> {
     }
 }
 
-
-
 //rules.test("debugger-scripts", "src/etc/lldb_batchmode.py")
 //     .run(move |s| dist::debugger_scripts(build, &build.sysroot(&s.compiler()),
 //                                     s.target));
@@ -438,6 +486,18 @@ pub struct DebuggerScripts<'a> {
 impl<'a> Step<'a> for DebuggerScripts<'a> {
     type Output = ();
 
+    fn should_run(_builder: &Builder, path: &Path) -> bool {
+        path.ends_with("src/etc/lldb_batchmode.py")
+    }
+
+    fn make_run(builder: &Builder, _path: Option<&Path>, host: &str, _target: &str) {
+        builder.ensure(DebuggerScripts {
+            // FIXME: builder.top_stage is likely wrong in some cases.
+            sysroot: &builder.sysroot(builder.compiler(builder.top_stage, host)),
+            host: host,
+        });
+    }
+
     /// Copies debugger scripts for `host` into the `sysroot` specified.
     fn run(self, builder: &Builder) {
         let build = builder.build;
@@ -542,6 +602,22 @@ pub struct Analysis<'a> {
 
 impl<'a> Step<'a> for Analysis<'a> {
     type Output = ();
+    const DEFAULT: bool = true;
+    const ONLY_BUILD_TARGETS: bool = true;
+
+    fn should_run(_builder: &Builder, path: &Path) -> bool {
+        path.ends_with("analysis")
+    }
+
+    fn make_run(builder: &Builder, path: Option<&Path>, host: &str, target: &str) {
+        if path.is_none() && !builder.build.config.extended {
+            return;
+        }
+        builder.ensure(Analysis {
+            compiler: builder.compiler(builder.top_stage, host),
+            target: target,
+        });
+    }
 
     /// Creates a tarball of save-analysis metadata, if available.
     fn run(self, builder: &Builder) {
@@ -559,15 +635,16 @@ impl<'a> Step<'a> for Analysis<'a> {
         // Package save-analysis from stage1 if not doing a full bootstrap, as the
         // stage2 artifacts is simply copied from stage1 in that case.
         let compiler = if build.force_use_stage1(compiler, target) {
-            Compiler::new(1, compiler.host)
+            builder.compiler(1, compiler.host)
         } else {
             compiler.clone()
         };
 
         let name = pkgname(build, "rust-analysis");
         let image = tmpdir(build).join(format!("{}-{}-image", name, target));
 
-        let src = build.stage_out(&compiler, Mode::Libstd).join(target).join("release").join("deps");
+        let src = build.stage_out(compiler, Mode::Libstd)
+            .join(target).join("release").join("deps");
 
         let image_src = src.join("save-analysis");
         let dst = image.join("lib/rustlib").join(target).join("analysis");
@@ -644,6 +721,18 @@ pub struct Src;
 
 impl<'a> Step<'a> for Src {
     type Output = ();
+    const DEFAULT: bool = true;
+    const ONLY_HOSTS: bool = true;
+    const ONLY_BUILD_TARGETS: bool = true;
+    const ONLY_BUILD: bool = true;
+
+    fn should_run(_builder: &Builder, path: &Path) -> bool {
+        path.ends_with("src")
+    }
+
+    fn make_run(builder: &Builder, _path: Option<&Path>, _host: &str, _target: &str) {
+        builder.ensure(Src);
+    }
 
     /// Creates the `rust-src` installer component
     fn run(self, builder: &Builder) {
@@ -727,6 +816,22 @@ pub struct PlainSourceTarball;
 
 impl<'a> Step<'a> for PlainSourceTarball {
     type Output = ();
+    const DEFAULT: bool = true;
+    const ONLY_HOSTS: bool = true;
+    const ONLY_BUILD_TARGETS: bool = true;
+    const ONLY_BUILD: bool = true;
+
+    fn should_run(_builder: &Builder, path: &Path) -> bool {
+        path.ends_with("src")
+    }
+
+    fn make_run(builder: &Builder, path: Option<&Path>, _host: &str, _target: &str) {
+        if path.is_none() && !builder.build.config.rust_dist_src {
+            return;
+        }
+
+        builder.ensure(PlainSourceTarball);
+    }
 
     /// Creates the plain source tarball
     fn run(self, builder: &Builder) {
@@ -862,13 +967,29 @@ pub struct Cargo<'a> {
 
 impl<'a> Step<'a> for Cargo<'a> {
     type Output = ();
+    const ONLY_BUILD_TARGETS: bool = true;
+    const ONLY_HOSTS: bool = true;
+
+    fn should_run(_builder: &Builder, path: &Path) -> bool {
+        path.ends_with("cargo")
+    }
+
+    fn make_run(builder: &Builder, _path: Option<&Path>, _host: &str, target: &str) {
+        builder.ensure(Cargo {
+            stage: builder.top_stage,
+            target: target,
+        });
+    }
 
     fn run(self, builder: &Builder) {
         let build = builder.build;
         let stage = self.stage;
         let target = self.target;
+
+        builder.ensure(tool::Cargo { stage, target });
+
         println!("Dist cargo stage{} ({})", stage, target);
-        let compiler = Compiler::new(stage, &build.build);
+        let compiler = builder.compiler(stage, &build.build);
 
         let src = build.src.join("src/tools/cargo");
         let etc = src.join("src/etc");
@@ -941,14 +1062,30 @@ pub struct Rls<'a> {
 
 impl<'a> Step<'a> for Rls<'a> {
     type Output = ();
+    const ONLY_BUILD_TARGETS: bool = true;
+    const ONLY_HOSTS: bool = true;
+
+    fn should_run(_builder: &Builder, path: &Path) -> bool {
+        path.ends_with("rls")
+    }
+
+    fn make_run(builder: &Builder, _path: Option<&Path>, _host: &str, target: &str) {
+        builder.ensure(Rls {
+            stage: builder.top_stage,
+            target: target,
+        });
+    }
 
     fn run(self, builder: &Builder) {
         let build = builder.build;
         let stage = self.stage;
         let target = self.target;
         assert!(build.config.extended);
+
+        builder.ensure(tool::Rls { stage, target });
+
         println!("Dist RLS stage{} ({})", stage, target);
-        let compiler = Compiler::new(stage, &build.build);
+        let compiler = builder.compiler(stage, &build.build);
 
         let src = build.src.join("src/tools/rls");
         let release_num = build.release_num("rls");
@@ -1017,12 +1154,38 @@ pub struct Extended<'a> {
 
 impl<'a> Step<'a> for Extended<'a> {
     type Output = ();
+    const DEFAULT: bool = true;
+    const ONLY_BUILD_TARGETS: bool = true;
+    const ONLY_HOSTS: bool = true;
+
+    fn should_run(_builder: &Builder, path: &Path) -> bool {
+        path.ends_with("cargo")
+    }
+
+    fn make_run(builder: &Builder, path: Option<&Path>, host: &str, target: &str) {
+        if path.is_none() && !builder.build.config.extended {
+            return;
+        }
+        builder.ensure(Extended {
+            compiler: builder.compiler(builder.top_stage, host),
+            target: target,
+        });
+    }
 
     /// Creates a combined installer for the specified target in the provided stage.
     fn run(self, builder: &Builder) {
         let build = builder.build;
         let stage = self.stage;
         let target = self.target;
+        let compiler = builder.compiler(stage, &build.build);
+
+        builder.ensure(Std { compiler, target });
+        builder.ensure(Rustc { stage, host });
+        builder.ensure(Mingw { host });
+        builder.ensure(Docs { stage, host });
+        builder.ensure(Cargo { stage, target });
+        builder.ensure(Rls { stage, target });
+        builder.ensure(Analysis { compiler, target });
 
         println!("Dist extended stage{} ({})", stage, target);
 
@@ -1420,11 +1583,21 @@ pub struct HashSign;
 
 impl<'a> Step<'a> for HashSign {
     type Output = ();
+    const ONLY_BUILD_TARGETS: bool = true;
+    const ONLY_HOSTS: bool = true;
+    const ONLY_BUILD: bool = true;
+
+    fn should_run(_builder: &Builder, path: &Path) -> bool {
+        path.ends_with("hash-and-sign")
+    }
+
+    fn make_run(builder: &Builder, _path: Option<&Path>, _host: &str, _target: &str) {
+        builder.ensure(HashSign);
+    }
 
     fn run(self, builder: &Builder) {
         let build = builder.build;
-        let compiler = Compiler::new(0, &build.build);
-        let mut cmd = build.tool_cmd(&compiler, "build-manifest");
+        let mut cmd = builder.tool_cmd(Tool::BuildManifest);
         let sign = build.config.dist_sign_folder.as_ref().unwrap_or_else(|| {
             panic!("\n\nfailed to specify `dist.sign-folder` in `config.toml`\n\n")
         });

src/bootstrap/dist.rs

@@ -148,45 +148,124 @@ fn add_destdir(path: &Path, destdir: &Option<PathBuf>) -> PathBuf {
     }
     ret
 }
-/*
-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));
-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));
-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));
-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));
-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));
-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));
-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));
-*/
+
+macro_rules! install {
+    ($($name:ident,
+       $path:expr,
+       $default_cond:expr,
+       only_hosts: $only_hosts:expr,
+       ($sel:ident, $builder:ident),
+       $run_item:block $(, $c:ident)*;)+) => {
+        $(#[derive(Serialize)]
+        pub struct $name<'a> {
+            pub stage: u32,
+            pub target: &'a str,
+            pub host: &'a str,
+        }
+
+        impl<'a> Step<'a> for $name<'a> {
+            type Output = ();
+            const NAME: &'static str = concat!("install ", stringify!($name));
+            const DEFAULT: bool = true;
+            const ONLY_BUILD_TARGETS: bool = true;
+            const ONLY_HOSTS: bool = $only_hosts;
+            $(const $c: bool = true;)*
+
+            fn should_run(_builder: &Builder, path: &Path) -> bool {
+                path.ends_with($path)
+            }
+
+            fn make_run($builder: &Builder, path: Option<&Path>, host: &str, target: &str) {
+                if path.is_none() && !($default_cond) {
+                    return;
+                }
+                $builder.ensure($name {
+                    stage: $builder.top_stage,
+                    target,
+                    host,
+                });
+            }
+
+            fn run($sel, $builder: &Builder) {
+                $run_item
+            }
+        })+
+    }
+}
+
+install!(
+    // 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, (self, builder), {
+        builder.ensure(dist::Docs { stage: self.stage, host: self.host });
+        Installer::new(builder.build).install_docs(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, (self, builder), {
+        builder.ensure(dist::Std {
+            compiler: builder.compiler(self.stage, self.host),
+            target: self.target
+        });
+        Installer::new(builder.build).install_std(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, (self, builder), {
+        builder.ensure(dist::Cargo { stage: self.stage, target: self.target });
+        Installer::new(builder.build).install_cargo(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, (self, builder), {
+        builder.ensure(dist::Rls { stage: self.stage, target: self.target });
+        Installer::new(builder.build).install_rls(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, (self, builder), {
+        builder.ensure(dist::Analysis {
+            compiler: builder.compiler(self.stage, self.host),
+            target: self.target
+        });
+        Installer::new(builder.build).install_analysis(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, (self, builder), {
+        builder.ensure(dist::Src);
+        Installer::new(builder.build).install_src(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, (self, builder), {
+        builder.ensure(dist::Rustc { stage: self.stage, host: self.host });
+        Installer::new(builder.build).install_rustc(self.stage, self.target);
+    };
+);

src/bootstrap/doc.rs

@@ -33,7 +33,7 @@ use Build;
 use util;
 use build_helper::up_to_date;
 
-/j/ rules.build("llvm", "src/llvm")
+// rules.build("llvm", "src/llvm")
 //      .host(true)
 //      .dep(move |s| {
 //          if s.target == build.build {
@@ -51,6 +51,7 @@ pub struct Llvm<'a> {
 
 impl<'a> Step<'a> for Llvm<'a> {
     type Output = ();
+    const ONLY_HOSTS: bool = true;
 
     /// Compile LLVM for `target`.
     fn run(self, builder: &Builder) {
@@ -151,6 +152,7 @@ impl<'a> Step<'a> for Llvm<'a> {
 
         // http://llvm.org/docs/HowToCrossCompileLLVM.html
         if target != build.build {
+            builder.ensure(Llvm { target: &build.build });
             // FIXME: if the llvm root for the build triple is overridden then we
             //        should use llvm-tblgen from there, also should verify that it
             //        actually exists most of the time in normal installs of LLVM.
@@ -249,6 +251,14 @@ pub struct TestHelpers<'a> {
 impl<'a> Step<'a> for TestHelpers<'a> {
     type Output = ();
 
+    fn should_run(_builder: &Builder, path: &Path) -> bool {
+        path.ends_with("src/rt/rust_test_helpers.c")
+    }
+
+    fn make_run(builder: &Builder, _path: Option<&Path>, _host: &str, target: &str) {
+        builder.ensure(TestHelpers { target })
+    }
+
     /// Compiles the `rust_test_helpers.c` library which we used in various
     /// `run-pass` test suites for ABI testing.
     fn run(self, builder: &Builder) {
@@ -295,12 +305,16 @@ const OPENSSL_SHA256: &'static str =
 
 #[derive(Serialize)]
 pub struct Openssl<'a> {
-    target: &'a str,
+    pub target: &'a str,
 }
 
 impl<'a> Step<'a> for Openssl<'a> {
     type Output = ();
 
+    fn should_run(_builder: &Builder, _path: &Path) -> bool {
+        false
+    }
+
     fn run(self, builder: &Builder) {
         let build = bulder.build;
         let target = self.target;

src/bootstrap/install.rs

@@ -15,7 +15,7 @@ use std::process::Command;
 use Mode;
 use builder::{Step, Builder};
 use util::{exe, add_lib_path};
-use compile::{self, stamp, Rustc};
+use compile::{self, libtest_stamp, libstd_stamp, librustc_stamp, Rustc};
 use native;
 use channel::GitInfo;
 
@@ -63,7 +63,7 @@ impl<'a> Step<'a> for CleanTools<'a> {
         let target = self.target;
         let mode = self.mode;
 
-        let compiler = Compiler::new(stage, &build.build);
+        let compiler = builder.compiler(stage, &build.build);
 
         let stamp = match mode {
             Mode::Libstd => libstd_stamp(build, &compiler, target),
@@ -76,103 +76,39 @@ impl<'a> Step<'a> for CleanTools<'a> {
     }
 }
 
-// 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"));
-// 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"));
-// 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"));
-// 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"));
-// 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"));
-// 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"));
-// 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"));
-// 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"));
-// rules.build("tool-remote-test-server", "src/tools/remote-test-server")
-//      .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-server"));
-// 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"));
-// 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"));
-// 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"));
-// 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(Serialize)]
-pub struct Tool<'a> {
+pub struct ToolBuild<'a> {
     pub stage: u32,
     pub target: &'a str,
     pub tool: &'a str,
+    pub mode: Mode,
 }
 
-impl<'a> Step<'a> for Tool<'a> {
-    type Output = ();
+impl<'a> Step<'a> for ToolBuild<'a> {
+    type Output = PathBuf;
 
     /// Build a tool in `src/tools`
     ///
     /// This will build the specified tool with the specified `host` compiler in
     /// `stage` into the normal cargo output directory.
-    fn run(self, builder: &Builder) {
+    fn run(self, builder: &Builder) -> PathBuf {
         let build = builder.build;
         let stage = self.stage;
         let target = self.target;
         let tool = self.tool;
 
+        let compiler = builder.compiler(stage, &build.build);
+        builder.ensure(CleanTools { stage, target, mode: self.mode });
+        match self.mode {
+            Mode::Libstd => builder.ensure(compile::Std { compiler, target }),
+            Mode::Libtest => builder.ensure(compile::Test { compiler, target }),
+            Mode::Librustc => builder.ensure(compile::Rustc { compiler, target }),
+            Mode::Tool => panic!("unexpected Mode::Tool for tool build")
+        }
+
         let _folder = build.fold_output(|| format!("stage{}-{}", stage, tool));
         println!("Building stage{} tool {} ({})", stage, tool, target);
 
-        let compiler = Compiler::new(stage, &build.build);
-
         let mut cargo = build.cargo(&compiler, Mode::Tool, target, "build");
         let dir = build.src.join("src/tools").join(tool);
         cargo.arg("--manifest-path").arg(dir.join("Cargo.toml"));
@@ -201,5 +137,238 @@ impl<'a> Step<'a> for Tool<'a> {
         }
 
         build.run(&mut cargo);
+        build.cargo_out(compiler, Mode::Tool, target).join(exe(tool, compiler.host))
+    }
+}
+
+macro_rules! tool {
+    ($($name:ident, $path:expr, $tool_name:expr, $mode:expr;)+) => {
+        #[derive(Copy, Clone)]
+        pub enum Tool {
+            $(
+                $name,
+            )+
+        }
+
+        impl<'a> Builder<'a> {
+            pub fn tool_exe(&self, tool: Tool) -> PathBuf {
+                match tool {
+                    $(Tool::$name =>
+                        self.ensure($name {
+                            stage: 0,
+                            target: &self.build.build,
+                        }),
+                    )+
+                }
+            }
+        }
+
+        $(
+        #[derive(Serialize)]
+        pub struct $name<'a> {
+            pub stage: u32,
+            pub target: &'a str,
+        }
+
+        impl<'a> Step<'a> for $name<'a> {
+            type Output = PathBuf;
+            const NAME: &'static str = concat!(stringify!($name), " tool");
+
+            fn should_run(_builder: &Builder, path: &Path) -> bool {
+                path.ends_with($path)
+            }
+
+            fn make_run(builder: &Builder, _path: Option<&Path>, _host: &str, target: &str) {
+                builder.ensure($name {
+                    stage: builder.top_stage,
+                    target,
+                });
+            }
+
+            fn run(self, builder: &Builder) -> PathBuf {
+                builder.ensure(ToolBuild {
+                    stage: self.stage,
+                    target: self.target,
+                    tool: $tool_name,
+                    mode: $mode,
+                })
+            }
+        }
+        )+
+    }
+}
+
+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"));
+    UnstableBook, "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::Libstd;
+    // rules.build("tool-remote-test-server", "src/tools/remote-test-server")
+    //      .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-server"));
+    RemoteTestServer, "src/tools/remote-test-server", "remote-test-server", Mode::Libstd;
+    // 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;
+);
+
+// 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(Serialize)]
+pub struct Cargo<'a> {
+    pub stage: u32,
+    pub target: &'a str,
+}
+
+impl<'a> Step<'a> for Cargo<'a> {
+    type Output = PathBuf;
+    const NAME: &'static str = "cargo tool";
+    const DEFAULT: bool = true;
+    const ONLY_HOSTS: bool = true;
+
+    fn should_run(_builder: &Builder, path: &Path) -> bool {
+        path.ends_with("src/tools/cargo")
+    }
+
+    fn make_run(builder: &Builder, path: Option<&Path>, _host: &str, target: &str) {
+        if path.is_none() && !builder.build.config.extended {
+            return;
+        }
+        builder.ensure(Cargo {
+            stage: builder.top_stage,
+            target,
+        });
+    }
+
+    fn run(self, builder: &Builder) -> PathBuf {
+        builder.ensure(native::Openssl {
+            target: self.target,
+        });
+        // Cargo depends on procedural macros, which requires a full host
+        // compiler to be available, so we need to depend on that.
+        builder.ensure(Rustc {
+            compiler: builder.compiler(builder.top_stage, &builder.build.build),
+            target: &builder.build.build,
+        });
+        builder.ensure(ToolBuild {
+            stage: self.stage,
+            target: self.target,
+            tool: "cargo",
+            mode: Mode::Libstd,
+        })
+    }
+}
+
+// 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(Serialize)]
+pub struct Rls<'a> {
+    pub stage: u32,
+    pub target: &'a str,
+}
+
+impl<'a> Step<'a> for Rls<'a> {
+    type Output = PathBuf;
+    const NAME: &'static str = "RLS tool";
+    const DEFAULT: bool = true;
+    const ONLY_HOSTS: bool = true;
+
+    fn should_run(_builder: &Builder, path: &Path) -> bool {
+        path.ends_with("src/tools/rls")
+    }
+
+    fn make_run(builder: &Builder, path: Option<&Path>, _host: &str, target: &str) {
+        if path.is_none() && !builder.build.config.extended {
+            return;
+        }
+        builder.ensure(Cargo {
+            stage: builder.top_stage,
+            target,
+        });
+    }
+
+    fn run(self, builder: &Builder) -> PathBuf {
+        builder.ensure(native::Openssl {
+            target: self.target,
+        });
+        // RLS depends on procedural macros, which requires a full host
+        // compiler to be available, so we need to depend on that.
+        builder.ensure(Rustc {
+            compiler: builder.compiler(builder.top_stage, &builder.build.build),
+            target: &builder.build.build,
+        });
+        builder.ensure(ToolBuild {
+            stage: self.stage,
+            target: self.target,
+            tool: "rls",
+            mode: Mode::Librustc,
+        })
     }
 }