use std::env;
use std::fs;
-use std::path::{Path, PathBuf, Component};
+use std::path::{Component, Path, PathBuf};
use std::process::Command;
+use build_helper::t;
+
use crate::dist::{self, pkgname, sanitize_sh, tmpdir};
+use crate::Compiler;
use crate::builder::{Builder, RunConfig, ShouldRun, Step};
use crate::cache::Interned;
package: &str,
name: &str,
stage: u32,
- host: Option<Interned<String>>
+ host: Option<Interned<String>>,
) {
builder.info(&format!("Install {} stage{} ({:?})", package, stage, host));
$(
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct $name {
- pub stage: u32,
+ pub compiler: Compiler,
pub target: Interned<String>,
- pub host: Interned<String>,
}
impl $name {
fn make_run(run: RunConfig<'_>) {
run.builder.ensure($name {
- stage: run.builder.top_stage,
+ compiler: run.builder.compiler(run.builder.top_stage, run.builder.config.build),
target: run.target,
- host: run.builder.config.build,
});
}
install!((self, builder, _config),
Docs, "src/doc", _config.docs, only_hosts: false, {
- builder.ensure(dist::Docs { stage: self.stage, host: self.target });
- install_docs(builder, self.stage, self.target);
+ builder.ensure(dist::Docs { host: self.target });
+ install_docs(builder, self.compiler.stage, self.target);
};
Std, "src/libstd", true, only_hosts: true, {
for target in &builder.targets {
builder.ensure(dist::Std {
- compiler: builder.compiler(self.stage, self.host),
+ compiler: self.compiler,
target: *target
});
- install_std(builder, self.stage, *target);
+ install_std(builder, self.compiler.stage, *target);
}
};
Cargo, "cargo", Self::should_build(_config), only_hosts: true, {
- builder.ensure(dist::Cargo { stage: self.stage, target: self.target });
- install_cargo(builder, self.stage, self.target);
+ builder.ensure(dist::Cargo { compiler: self.compiler, target: self.target });
+ install_cargo(builder, self.compiler.stage, self.target);
};
Rls, "rls", Self::should_build(_config), only_hosts: true, {
- if builder.ensure(dist::Rls { stage: self.stage, target: self.target }).is_some() ||
+ if builder.ensure(dist::Rls { compiler: self.compiler, target: self.target }).is_some() ||
Self::should_install(builder) {
- install_rls(builder, self.stage, self.target);
+ install_rls(builder, self.compiler.stage, self.target);
} else {
- builder.info(&format!("skipping Install RLS stage{} ({})", self.stage, self.target));
+ builder.info(
+ &format!("skipping Install RLS stage{} ({})", self.compiler.stage, self.target),
+ );
}
};
Clippy, "clippy", Self::should_build(_config), only_hosts: true, {
- if builder.ensure(dist::Clippy { stage: self.stage, target: self.target }).is_some() ||
- Self::should_install(builder) {
- install_clippy(builder, self.stage, self.target);
+ if builder.ensure(dist::Clippy {
+ compiler: self.compiler,
+ target: self.target,
+ }).is_some() || Self::should_install(builder) {
+ install_clippy(builder, self.compiler.stage, self.target);
} else {
- builder.info(&format!("skipping Install clippy stage{} ({})", self.stage, self.target));
+ builder.info(
+ &format!("skipping Install clippy stage{} ({})", self.compiler.stage, self.target),
+ );
}
};
Miri, "miri", Self::should_build(_config), only_hosts: true, {
- if builder.ensure(dist::Miri { stage: self.stage, target: self.target }).is_some() ||
+ if builder.ensure(dist::Miri { compiler: self.compiler, target: self.target }).is_some() ||
Self::should_install(builder) {
- install_miri(builder, self.stage, self.target);
+ install_miri(builder, self.compiler.stage, self.target);
} else {
- builder.info(&format!("skipping Install miri stage{} ({})", self.stage, self.target));
+ builder.info(
+ &format!("skipping Install miri stage{} ({})", self.compiler.stage, self.target),
+ );
}
};
Rustfmt, "rustfmt", Self::should_build(_config), only_hosts: true, {
- if builder.ensure(dist::Rustfmt { stage: self.stage, target: self.target }).is_some() ||
- Self::should_install(builder) {
- install_rustfmt(builder, self.stage, self.target);
+ if builder.ensure(dist::Rustfmt {
+ compiler: self.compiler,
+ target: self.target
+ }).is_some() || Self::should_install(builder) {
+ install_rustfmt(builder, self.compiler.stage, self.target);
} else {
builder.info(
- &format!("skipping Install Rustfmt stage{} ({})", self.stage, self.target));
+ &format!("skipping Install Rustfmt stage{} ({})", self.compiler.stage, self.target),
+ );
}
};
Analysis, "analysis", Self::should_build(_config), only_hosts: false, {
builder.ensure(dist::Analysis {
- compiler: builder.compiler(self.stage, self.host),
+ compiler: self.compiler,
target: self.target
});
- install_analysis(builder, self.stage, self.target);
+ install_analysis(builder, self.compiler.stage, self.target);
};
Rustc, "src/librustc", true, only_hosts: true, {
builder.ensure(dist::Rustc {
- compiler: builder.compiler(self.stage, self.target),
+ compiler: self.compiler,
});
- install_rustc(builder, self.stage, self.target);
+ install_rustc(builder, self.compiler.stage, self.target);
};
);
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
let config = &run.builder.config;
- let cond = config.extended &&
- config.tools.as_ref().map_or(true, |t| t.contains("src"));
+ let cond = config.extended && config.tools.as_ref().map_or(true, |t| t.contains("src"));
run.path("src").default_condition(cond)
}
fn make_run(run: RunConfig<'_>) {
- run.builder.ensure(Src {
- stage: run.builder.top_stage,
- });
+ run.builder.ensure(Src { stage: run.builder.top_stage });
}
fn run(self, builder: &Builder<'_>) {