user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

adapt tool module to ToolBuildResult

Browse source 
Signed-off-by: onur-ozkan <work@onurozkan.dev>
This commit is contained in:
onur-ozkan 2025-02-18 16:00:06 +00:00
parent 5e5b1b054a
commit baef666f78
6 changed files with 189 additions and 179 deletions
Download patch file Download diff file Expand all files Collapse all files

26
src/bootstrap/src/core/build_steps/compile.rs
View file

@ -1977,13 +1977,14 @@ impl Step for Assemble {
let maybe_install_llvm_bitcode_linker = |compiler| {
if builder.config.llvm_bitcode_linker_enabled {
trace!("llvm-bitcode-linker enabled, installing");
let src_path = builder.ensure(crate::core::build_steps::tool::LlvmBitcodeLinker {
compiler,
target: target_compiler.host,
extra_features: vec![],
});
let llvm_bitcode_linker =
builder.ensure(crate::core::build_steps::tool::LlvmBitcodeLinker {
compiler,
target: target_compiler.host,
extra_features: vec![],
});
let tool_exe = exe("llvm-bitcode-linker", target_compiler.host);
builder.copy_link(&src_path, &libdir_bin.join(tool_exe));
builder.copy_link(&llvm_bitcode_linker.tool_path, &libdir_bin.join(tool_exe));
}
};
@ -2171,14 +2172,13 @@ impl Step for Assemble {
// logic to create the final binary. This is used by the
// `wasm32-wasip2` target of Rust.
if builder.tool_enabled("wasm-component-ld") {
let wasm_component_ld_exe =
builder.ensure(crate::core::build_steps::tool::WasmComponentLd {
compiler: build_compiler,
target: target_compiler.host,
});
let wasm_component = builder.ensure(crate::core::build_steps::tool::WasmComponentLd {
compiler: build_compiler,
target: target_compiler.host,
});
builder.copy_link(
&wasm_component_ld_exe,
&libdir_bin.join(wasm_component_ld_exe.file_name().unwrap()),
&wasm_component.tool_path,
&libdir_bin.join(wasm_component.tool_path.file_name().unwrap()),
);
}

8
src/bootstrap/src/core/build_steps/dist.rs
View file

@ -430,7 +430,7 @@ impl Step for Rustc {
},
builder.kind,
) {
builder.install(&ra_proc_macro_srv, &image.join("libexec"), 0o755);
builder.install(&ra_proc_macro_srv.tool_path, &image.join("libexec"), 0o755);
}
let libdir_relative = builder.libdir_relative(compiler);
@ -1134,7 +1134,7 @@ impl Step for Cargo {
let mut tarball = Tarball::new(builder, "cargo", &target.triple);
tarball.set_overlay(OverlayKind::Cargo);
tarball.add_file(cargo, "bin", 0o755);
tarball.add_file(cargo.tool_path, "bin", 0o755);
tarball.add_file(etc.join("_cargo"), "share/zsh/site-functions", 0o644);
tarball.add_renamed_file(etc.join("cargo.bashcomp.sh"), "etc/bash_completion.d", "cargo");
tarball.add_dir(etc.join("man"), "share/man/man1");
@ -1222,7 +1222,7 @@ impl Step for RustAnalyzer {
let mut tarball = Tarball::new(builder, "rust-analyzer", &target.triple);
tarball.set_overlay(OverlayKind::RustAnalyzer);
tarball.is_preview(true);
tarball.add_file(rust_analyzer, "bin", 0o755);
tarball.add_file(rust_analyzer.tool_path, "bin", 0o755);
tarball.add_legal_and_readme_to("share/doc/rust-analyzer");
Some(tarball.generate())
}
@ -2272,7 +2272,7 @@ impl Step for LlvmBitcodeLinker {
tarball.set_overlay(OverlayKind::LlvmBitcodeLinker);
tarball.is_preview(true);
tarball.add_file(llbc_linker, self_contained_bin_dir, 0o755);
tarball.add_file(llbc_linker.tool_path, self_contained_bin_dir, 0o755);
Some(tarball.generate())
}

2
src/bootstrap/src/core/build_steps/perf.rs
View file

@ -166,7 +166,7 @@ Consider setting `rust.debuginfo-level = 1` in `config.toml`."#);
let results_dir = rustc_perf_dir.join("results");
builder.create_dir(&results_dir);
let mut cmd = command(collector);
let mut cmd = command(collector.tool_path);
// We need to set the working directory to `src/tools/rustc-perf`, so that it can find the directory
// with compile-time benchmarks.

18
src/bootstrap/src/core/build_steps/test.rs
View file

@ -263,7 +263,7 @@ impl Step for Cargotest {
let _time = helpers::timeit(builder);
let mut cmd = builder.tool_cmd(Tool::CargoTest);
cmd.arg(&cargo)
cmd.arg(&cargo.tool_path)
.arg(&out_dir)
.args(builder.config.test_args())
.env("RUSTC", builder.rustc(compiler))
@ -1718,7 +1718,7 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
// If we're using `--stage 0`, we should provide the bootstrap cargo.
builder.initial_cargo.clone()
} else {
builder.ensure(tool::Cargo { compiler, target: compiler.host })
builder.ensure(tool::Cargo { compiler, target: compiler.host }).tool_path
};
cmd.arg("--cargo-path").arg(cargo_path);
@ -1739,9 +1739,10 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
// Use the beta compiler for jsondocck
let json_compiler = compiler.with_stage(0);
cmd.arg("--jsondocck-path")
.arg(builder.ensure(tool::JsonDocCk { compiler: json_compiler, target }));
cmd.arg("--jsondoclint-path")
.arg(builder.ensure(tool::JsonDocLint { compiler: json_compiler, target }));
.arg(builder.ensure(tool::JsonDocCk { compiler: json_compiler, target }).tool_path);
cmd.arg("--jsondoclint-path").arg(
builder.ensure(tool::JsonDocLint { compiler: json_compiler, target }).tool_path,
);
}
if matches!(mode, "coverage-map" | "coverage-run") {
@ -2976,12 +2977,15 @@ impl Step for RemoteCopyLibs {
builder.info(&format!("REMOTE copy libs to emulator ({target})"));
let server = builder.ensure(tool::RemoteTestServer { compiler, target });
let remote_test_server = builder.ensure(tool::RemoteTestServer { compiler, target });
// Spawn the emulator and wait for it to come online
let tool = builder.tool_exe(Tool::RemoteTestClient);
let mut cmd = command(&tool);
cmd.arg("spawn-emulator").arg(target.triple).arg(&server).arg(builder.tempdir());
cmd.arg("spawn-emulator")
.arg(target.triple)
.arg(&remote_test_server.tool_path)
.arg(builder.tempdir());
if let Some(rootfs) = builder.qemu_rootfs(target) {
cmd.arg(rootfs);
}

312
src/bootstrap/src/core/build_steps/tool.rs
View file

@ -347,7 +347,7 @@ macro_rules! bootstrap_tool {
self.ensure($name {
compiler: self.compiler(0, self.config.build),
target: self.config.build,
}),
}).tool_path,
)+
}
}
@ -361,7 +361,7 @@ macro_rules! bootstrap_tool {
}
impl Step for $name {
type Output = PathBuf;
type Output = ToolBuildResult;
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
run.path($path)
@ -383,7 +383,7 @@ macro_rules! bootstrap_tool {
skip_all,
),
)]
fn run(self, builder: &Builder<'_>) -> PathBuf {
fn run(self, builder: &Builder<'_>) -> ToolBuildResult {
$(
for submodule in $submodules {
builder.require_submodule(submodule, None);
@ -408,7 +408,7 @@ macro_rules! bootstrap_tool {
extra_features: vec![],
allow_features: concat!($($allow_features)*),
cargo_args: vec![]
}).tool_path
})
}
}
)+
@ -458,7 +458,7 @@ pub struct OptimizedDist {
}
impl Step for OptimizedDist {
type Output = PathBuf;
type Output = ToolBuildResult;
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
run.path("src/tools/opt-dist")
@ -471,24 +471,22 @@ impl Step for OptimizedDist {
});
}
fn run(self, builder: &Builder<'_>) -> PathBuf {
fn run(self, builder: &Builder<'_>) -> ToolBuildResult {
// We need to ensure the rustc-perf submodule is initialized when building opt-dist since
// the tool requires it to be in place to run.
builder.require_submodule("src/tools/rustc-perf", None);
builder
.ensure(ToolBuild {
compiler: self.compiler,
target: self.target,
tool: "opt-dist",
mode: Mode::ToolBootstrap,
path: "src/tools/opt-dist",
source_type: SourceType::InTree,
extra_features: Vec::new(),
allow_features: "",
cargo_args: Vec::new(),
})
.tool_path
builder.ensure(ToolBuild {
compiler: self.compiler,
target: self.target,
tool: "opt-dist",
mode: Mode::ToolBootstrap,
path: "src/tools/opt-dist",
source_type: SourceType::InTree,
extra_features: Vec::new(),
allow_features: "",
cargo_args: Vec::new(),
})
}
}
@ -502,7 +500,7 @@ pub struct RustcPerf {
impl Step for RustcPerf {
/// Path to the built `collector` binary.
type Output = PathBuf;
type Output = ToolBuildResult;
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
run.path("src/tools/rustc-perf")
@ -515,7 +513,7 @@ impl Step for RustcPerf {
});
}
fn run(self, builder: &Builder<'_>) -> PathBuf {
fn run(self, builder: &Builder<'_>) -> ToolBuildResult {
// We need to ensure the rustc-perf submodule is initialized.
builder.require_submodule("src/tools/rustc-perf", None);
@ -532,12 +530,12 @@ impl Step for RustcPerf {
// a CLI.
cargo_args: vec!["-p".to_string(), "collector".to_string()],
};
let collector_bin = builder.ensure(tool.clone()).tool_path;
let res = builder.ensure(tool.clone());
// We also need to symlink the `rustc-fake` binary to the corresponding directory,
// because `collector` expects it in the same directory.
copy_link_tool_bin(builder, tool.compiler, tool.target, tool.mode, "rustc-fake");
collector_bin
res
}
}
@ -552,7 +550,7 @@ impl ErrorIndex {
// for rustc_private and libLLVM.so, and `sysroot_lib` for libstd, etc.
let host = builder.config.build;
let compiler = builder.compiler_for(builder.top_stage, host, host);
let mut cmd = command(builder.ensure(ErrorIndex { compiler }));
let mut cmd = command(builder.ensure(ErrorIndex { compiler }).tool_path);
let mut dylib_paths = builder.rustc_lib_paths(compiler);
dylib_paths.push(PathBuf::from(&builder.sysroot_target_libdir(compiler, compiler.host)));
add_dylib_path(dylib_paths, &mut cmd);
@ -561,16 +559,13 @@ impl ErrorIndex {
}
impl Step for ErrorIndex {
type Output = PathBuf;
type Output = ToolBuildResult;
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
run.path("src/tools/error_index_generator")
}
fn make_run(run: RunConfig<'_>) {
// Compile the error-index in the same stage as rustdoc to avoid
// recompiling rustdoc twice if we can.
//
// NOTE: This `make_run` isn't used in normal situations, only if you
// manually build the tool with `x.py build
// src/tools/error-index-generator` which almost nobody does.
@ -580,20 +575,18 @@ impl Step for ErrorIndex {
run.builder.ensure(ErrorIndex { compiler });
}
fn run(self, builder: &Builder<'_>) -> PathBuf {
builder
.ensure(ToolBuild {
compiler: self.compiler,
target: self.compiler.host,
tool: "error_index_generator",
mode: Mode::ToolRustc,
path: "src/tools/error_index_generator",
source_type: SourceType::InTree,
extra_features: Vec::new(),
allow_features: "",
cargo_args: Vec::new(),
})
.tool_path
fn run(self, builder: &Builder<'_>) -> ToolBuildResult {
builder.ensure(ToolBuild {
compiler: self.compiler,
target: self.compiler.host,
tool: "error_index_generator",
mode: Mode::ToolRustc,
path: "src/tools/error_index_generator",
source_type: SourceType::InTree,
extra_features: Vec::new(),
allow_features: "",
cargo_args: Vec::new(),
})
}
}
@ -604,7 +597,7 @@ pub struct RemoteTestServer {
}
impl Step for RemoteTestServer {
type Output = PathBuf;
type Output = ToolBuildResult;
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
run.path("src/tools/remote-test-server")
@ -617,20 +610,18 @@ impl Step for RemoteTestServer {
});
}
fn run(self, builder: &Builder<'_>) -> PathBuf {
builder
.ensure(ToolBuild {
compiler: self.compiler,
target: self.target,
tool: "remote-test-server",
mode: Mode::ToolStd,
path: "src/tools/remote-test-server",
source_type: SourceType::InTree,
extra_features: Vec::new(),
allow_features: "",
cargo_args: Vec::new(),
})
.tool_path
fn run(self, builder: &Builder<'_>) -> ToolBuildResult {
builder.ensure(ToolBuild {
compiler: self.compiler,
target: self.target,
tool: "remote-test-server",
mode: Mode::ToolStd,
path: "src/tools/remote-test-server",
source_type: SourceType::InTree,
extra_features: Vec::new(),
allow_features: "",
cargo_args: Vec::new(),
})
}
}
@ -642,7 +633,7 @@ pub struct Rustdoc {
}
impl Step for Rustdoc {
type Output = PathBuf;
type Output = ToolBuildResult;
const DEFAULT: bool = true;
const ONLY_HOSTS: bool = true;
@ -655,15 +646,21 @@ impl Step for Rustdoc {
.ensure(Rustdoc { compiler: run.builder.compiler(run.builder.top_stage, run.target) });
}
fn run(self, builder: &Builder<'_>) -> PathBuf {
fn run(self, builder: &Builder<'_>) -> ToolBuildResult {
let target_compiler = self.compiler;
let target = target_compiler.host;
if target_compiler.stage == 0 {
if !target_compiler.is_snapshot(builder) {
panic!("rustdoc in stage 0 must be snapshot rustdoc");
}
return builder.initial_rustdoc.clone();
return ToolBuildResult {
tool_path: builder.initial_rustdoc.clone(),
build_compiler: target_compiler,
target_compiler,
};
}
let target = target_compiler.host;
let bin_rustdoc = || {
let sysroot = builder.sysroot(target_compiler);
@ -693,7 +690,12 @@ impl Step for Rustdoc {
let bin_rustdoc = bin_rustdoc();
builder.copy_link(&precompiled_rustdoc, &bin_rustdoc);
return bin_rustdoc;
return ToolBuildResult {
tool_path: bin_rustdoc,
build_compiler: target_compiler,
target_compiler,
};
}
}
@ -709,7 +711,7 @@ impl Step for Rustdoc {
extra_features.push("jemalloc".to_string());
}
let ToolBuildResult { tool_path, build_compiler: _build_compiler, target_compiler } =
let ToolBuildResult { tool_path, build_compiler, target_compiler } =
builder.ensure(ToolBuild {
compiler: target_compiler,
target,
@ -734,9 +736,9 @@ impl Step for Rustdoc {
}
let bin_rustdoc = bin_rustdoc();
builder.copy_link(&tool_path, &bin_rustdoc);
bin_rustdoc
ToolBuildResult { tool_path: bin_rustdoc, build_compiler, target_compiler }
} else {
tool_path
ToolBuildResult { tool_path, build_compiler, target_compiler }
}
}
}
@ -748,7 +750,7 @@ pub struct Cargo {
}
impl Step for Cargo {
type Output = PathBuf;
type Output = ToolBuildResult;
const DEFAULT: bool = true;
const ONLY_HOSTS: bool = true;
@ -764,22 +766,20 @@ impl Step for Cargo {
});
}
fn run(self, builder: &Builder<'_>) -> PathBuf {
fn run(self, builder: &Builder<'_>) -> ToolBuildResult {
builder.build.require_submodule("src/tools/cargo", None);
builder
.ensure(ToolBuild {
compiler: self.compiler,
target: self.target,
tool: "cargo",
mode: Mode::ToolRustc,
path: "src/tools/cargo",
source_type: SourceType::Submodule,
extra_features: Vec::new(),
allow_features: "",
cargo_args: Vec::new(),
})
.tool_path
builder.ensure(ToolBuild {
compiler: self.compiler,
target: self.target,
tool: "cargo",
mode: Mode::ToolRustc,
path: "src/tools/cargo",
source_type: SourceType::Submodule,
extra_features: Vec::new(),
allow_features: "",
cargo_args: Vec::new(),
})
}
}
@ -790,7 +790,7 @@ pub struct LldWrapper {
}
impl Step for LldWrapper {
type Output = ();
type Output = ToolBuildResult;
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
run.never()
@ -805,26 +805,29 @@ impl Step for LldWrapper {
fields(build_compiler = ?self.build_compiler, target_compiler = ?self.target_compiler),
),
)]
fn run(self, builder: &Builder<'_>) {
fn run(self, builder: &Builder<'_>) -> ToolBuildResult {
if builder.config.dry_run() {
return;
return ToolBuildResult {
tool_path: Default::default(),
build_compiler: self.build_compiler,
target_compiler: self.target_compiler,
};
}
let target = self.target_compiler.host;
let executable = builder
.ensure(ToolBuild {
compiler: self.build_compiler,
target,
tool: "lld-wrapper",
mode: Mode::ToolStd,
path: "src/tools/lld-wrapper",
source_type: SourceType::InTree,
extra_features: Vec::new(),
allow_features: "",
cargo_args: Vec::new(),
})
.tool_path;
let tool_result = builder.ensure(ToolBuild {
compiler: self.build_compiler,
target,
tool: "lld-wrapper",
mode: Mode::ToolStd,
path: "src/tools/lld-wrapper",
source_type: SourceType::InTree,
extra_features: Vec::new(),
allow_features: "",
cargo_args: Vec::new(),
});
let libdir_bin = builder.sysroot_target_bindir(self.target_compiler, target);
t!(fs::create_dir_all(&libdir_bin));
@ -838,8 +841,11 @@ impl Step for LldWrapper {
t!(fs::create_dir_all(&self_contained_lld_dir));
for name in crate::LLD_FILE_NAMES {
builder.copy_link(&executable, &self_contained_lld_dir.join(exe(name, target)));
builder
.copy_link(&tool_result.tool_path, &self_contained_lld_dir.join(exe(name, target)));
}
tool_result
}
}
@ -854,7 +860,7 @@ impl RustAnalyzer {
}
impl Step for RustAnalyzer {
type Output = PathBuf;
type Output = ToolBuildResult;
const DEFAULT: bool = true;
const ONLY_HOSTS: bool = true;
@ -870,20 +876,18 @@ impl Step for RustAnalyzer {
});
}
fn run(self, builder: &Builder<'_>) -> PathBuf {
builder
.ensure(ToolBuild {
compiler: self.compiler,
target: self.target,
tool: "rust-analyzer",
mode: Mode::ToolRustc,
path: "src/tools/rust-analyzer",
extra_features: vec!["in-rust-tree".to_owned()],
source_type: SourceType::InTree,
allow_features: RustAnalyzer::ALLOW_FEATURES,
cargo_args: Vec::new(),
})
.tool_path
fn run(self, builder: &Builder<'_>) -> ToolBuildResult {
builder.ensure(ToolBuild {
compiler: self.compiler,
target: self.target,
tool: "rust-analyzer",
mode: Mode::ToolRustc,
path: "src/tools/rust-analyzer",
extra_features: vec!["in-rust-tree".to_owned()],
source_type: SourceType::InTree,
allow_features: RustAnalyzer::ALLOW_FEATURES,
cargo_args: Vec::new(),
})
}
}
@ -894,7 +898,7 @@ pub struct RustAnalyzerProcMacroSrv {
}
impl Step for RustAnalyzerProcMacroSrv {
type Output = Option<PathBuf>;
type Output = Option<ToolBuildResult>;
const DEFAULT: bool = true;
const ONLY_HOSTS: bool = true;
@ -916,28 +920,27 @@ impl Step for RustAnalyzerProcMacroSrv {
});
}
fn run(self, builder: &Builder<'_>) -> Option<PathBuf> {
let path = builder
.ensure(ToolBuild {
compiler: self.compiler,
target: self.target,
tool: "rust-analyzer-proc-macro-srv",
mode: Mode::ToolRustc,
path: "src/tools/rust-analyzer/crates/proc-macro-srv-cli",
extra_features: vec!["in-rust-tree".to_owned()],
source_type: SourceType::InTree,
allow_features: RustAnalyzer::ALLOW_FEATURES,
cargo_args: Vec::new(),
})
.tool_path;
fn run(self, builder: &Builder<'_>) -> Option<ToolBuildResult> {
let tool_result = builder.ensure(ToolBuild {
compiler: self.compiler,
target: self.target,
tool: "rust-analyzer-proc-macro-srv",
mode: Mode::ToolRustc,
path: "src/tools/rust-analyzer/crates/proc-macro-srv-cli",
extra_features: vec!["in-rust-tree".to_owned()],
source_type: SourceType::InTree,
allow_features: RustAnalyzer::ALLOW_FEATURES,
cargo_args: Vec::new(),
});
// Copy `rust-analyzer-proc-macro-srv` to `<sysroot>/libexec/`
// so that r-a can use it.
let libexec_path = builder.sysroot(self.compiler).join("libexec");
t!(fs::create_dir_all(&libexec_path));
builder.copy_link(&path, &libexec_path.join("rust-analyzer-proc-macro-srv"));
builder
.copy_link(&tool_result.tool_path, &libexec_path.join("rust-analyzer-proc-macro-srv"));
Some(path)
Some(tool_result)
}
}
@ -949,7 +952,7 @@ pub struct LlvmBitcodeLinker {
}
impl Step for LlvmBitcodeLinker {
type Output = PathBuf;
type Output = ToolBuildResult;
const DEFAULT: bool = true;
const ONLY_HOSTS: bool = true;
@ -971,31 +974,34 @@ impl Step for LlvmBitcodeLinker {
feature = "tracing",
instrument(level = "debug", name = "LlvmBitcodeLinker::run", skip_all)
)]
fn run(self, builder: &Builder<'_>) -> PathBuf {
let ToolBuildResult { tool_path, build_compiler: _build_compiler, target_compiler } =
builder.ensure(ToolBuild {
compiler: self.compiler,
target: self.target,
tool: "llvm-bitcode-linker",
mode: Mode::ToolRustc,
path: "src/tools/llvm-bitcode-linker",
source_type: SourceType::InTree,
extra_features: self.extra_features,
allow_features: "",
cargo_args: Vec::new(),
});
fn run(self, builder: &Builder<'_>) -> ToolBuildResult {
let tool_result = builder.ensure(ToolBuild {
compiler: self.compiler,
target: self.target,
tool: "llvm-bitcode-linker",
mode: Mode::ToolRustc,
path: "src/tools/llvm-bitcode-linker",
source_type: SourceType::InTree,
extra_features: self.extra_features,
allow_features: "",
cargo_args: Vec::new(),
});
if target_compiler.stage > 0 {
if tool_result.target_compiler.stage > 0 {
let bindir_self_contained = builder
.sysroot(target_compiler)
.sysroot(tool_result.target_compiler)
.join(format!("lib/rustlib/{}/bin/self-contained", self.target.triple));
t!(fs::create_dir_all(&bindir_self_contained));
let bin_destination =
bindir_self_contained.join(exe("llvm-bitcode-linker", target_compiler.host));
builder.copy_link(&tool_path, &bin_destination);
bin_destination
let bin_destination = bindir_self_contained
.join(exe("llvm-bitcode-linker", tool_result.target_compiler.host));
builder.copy_link(&tool_result.tool_path, &bin_destination);
ToolBuildResult {
tool_path: bin_destination,
build_compiler: tool_result.build_compiler,
target_compiler: tool_result.target_compiler,
}
} else {
tool_path
tool_result
}
}
}
@ -1214,7 +1220,7 @@ pub struct TestFloatParse {
}
impl Step for TestFloatParse {
type Output = ();
type Output = ToolBuildResult;
const ONLY_HOSTS: bool = true;
const DEFAULT: bool = false;
@ -1222,7 +1228,7 @@ impl Step for TestFloatParse {
run.path("src/etc/test-float-parse")
}
fn run(self, builder: &Builder<'_>) {
fn run(self, builder: &Builder<'_>) -> ToolBuildResult {
let bootstrap_host = builder.config.build;
let compiler = builder.compiler(builder.top_stage, bootstrap_host);
@ -1236,7 +1242,7 @@ impl Step for TestFloatParse {
extra_features: Vec::new(),
allow_features: "",
cargo_args: Vec::new(),
});
})
}
}

2
src/bootstrap/src/core/builder/mod.rs
View file

@ -1392,7 +1392,7 @@ impl<'a> Builder<'a> {
}
pub fn rustdoc(&self, compiler: Compiler) -> PathBuf {
self.ensure(tool::Rustdoc { compiler })
self.ensure(tool::Rustdoc { compiler }).tool_path
}
pub fn cargo_clippy_cmd(&self, run_compiler: Compiler) -> BootstrapCommand {