use serde::Deserialize;
+use crate::builder::crate_description;
use crate::builder::Cargo;
use crate::builder::{Builder, Kind, RunConfig, ShouldRun, Step};
use crate::cache::{Interned, INTERNER};
let compiler_to_use = builder.compiler_for(compiler.stage, compiler.host, target);
if compiler_to_use != compiler {
builder.ensure(Std::new(compiler_to_use, target));
- builder.info(&format!("Uplifting stage1 std ({} -> {})", compiler_to_use.host, target));
+ builder.info(&format!(
+ "Uplifting stage1 library ({} -> {})",
+ compiler_to_use.host, target
+ ));
// Even if we're not building std this stage, the new sysroot must
// still contain the third party objects needed by various targets.
let mut cargo = builder.cargo(compiler, Mode::Std, SourceType::InTree, target, "build");
std_cargo(builder, target, compiler.stage, &mut cargo);
+ for krate in &*self.crates {
+ cargo.arg("-p").arg(krate);
+ }
builder.info(&format!(
- "Building stage{} std artifacts ({} -> {})",
- compiler.stage, &compiler.host, target
+ "Building{} stage{} library artifacts ({} -> {})",
+ crate_description(&self.crates),
+ compiler.stage,
+ &compiler.host,
+ target,
));
- run_cargo(
- builder,
- cargo,
- self.crates.to_vec(),
- &libstd_stamp(builder, compiler, target),
- target_deps,
- false,
- );
+ run_cargo(builder, cargo, &libstd_stamp(builder, compiler, target), target_deps, false);
builder.ensure(StdLink::from_std(
self,
let target_compiler = self.target_compiler;
let target = self.target;
builder.info(&format!(
- "Copying stage{} std from stage{} ({} -> {} / {})",
+ "Copying stage{} library from stage{} ({} -> {} / {})",
target_compiler.stage, compiler.stage, &compiler.host, target_compiler.host, target
));
let libdir = builder.sysroot_libdir(target_compiler, target);
}
}
+ for krate in &*self.crates {
+ cargo.arg("-p").arg(krate);
+ }
+
builder.info(&format!(
- "Building stage{} compiler artifacts ({} -> {})",
- compiler.stage, &compiler.host, target
+ "Building{} stage{} compiler artifacts ({} -> {})",
+ crate_description(&self.crates),
+ compiler.stage,
+ &compiler.host,
+ target,
));
- run_cargo(
- builder,
- cargo,
- self.crates.to_vec(),
- &librustc_stamp(builder, compiler, target),
- vec![],
- false,
- );
+ run_cargo(builder, cargo, &librustc_stamp(builder, compiler, target), vec![], false);
builder.ensure(RustcLink::from_rustc(
self,
"Building stage{} codegen backend {} ({} -> {})",
compiler.stage, backend, &compiler.host, target
));
- let files = run_cargo(builder, cargo, vec![], &tmp_stamp, vec![], false);
+ let files = run_cargo(builder, cargo, &tmp_stamp, vec![], false);
if builder.config.dry_run() {
return;
}
pub fn run_cargo(
builder: &Builder<'_>,
cargo: Cargo,
- tail_args: Vec<String>,
stamp: &Path,
additional_target_deps: Vec<(PathBuf, DependencyType)>,
is_check: bool,
// files we need to probe for later.
let mut deps = Vec::new();
let mut toplevel = Vec::new();
- let ok = stream_cargo(builder, cargo, tail_args, &mut |msg| {
+ let ok = stream_cargo(builder, cargo, &mut |msg| {
let (filenames, crate_types) = match msg {
CargoMessage::CompilerArtifact {
filenames,
pub fn stream_cargo(
builder: &Builder<'_>,
cargo: Cargo,
- tail_args: Vec<String>,
cb: &mut dyn FnMut(CargoMessage<'_>),
) -> bool {
let mut cargo = Command::from(cargo);
}
cargo.arg("--message-format").arg(message_format).stdout(Stdio::piped());
- for arg in tail_args {
- cargo.arg(arg);
- }
-
builder.verbose(&format!("running: {:?}", cargo));
let mut child = match cargo.spawn() {
Ok(child) => child,