use crate::cache::{Interned, INTERNER};
use crate::compile;
use crate::config::TargetSelection;
-use crate::tarball::{OverlayKind, Tarball};
+use crate::tarball::{GeneratedTarball, OverlayKind, Tarball};
use crate::tool::{self, Tool};
use crate::util::{exe, is_dylib, timeit};
use crate::{Compiler, DependencyType, Mode, LLVM_TOOLS};
}
impl Step for Docs {
- type Output = Option<PathBuf>;
+ type Output = Option<GeneratedTarball>;
const DEFAULT: bool = true;
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
}
/// Builds the `rust-docs` installer component.
- fn run(self, builder: &Builder<'_>) -> Option<PathBuf> {
+ fn run(self, builder: &Builder<'_>) -> Option<GeneratedTarball> {
let host = self.host;
if !builder.config.docs {
return None;
}
impl Step for RustcDocs {
- type Output = Option<PathBuf>;
+ type Output = Option<GeneratedTarball>;
const DEFAULT: bool = true;
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
}
/// Builds the `rustc-docs` installer component.
- fn run(self, builder: &Builder<'_>) -> Option<PathBuf> {
+ fn run(self, builder: &Builder<'_>) -> Option<GeneratedTarball> {
let host = self.host;
if !builder.config.compiler_docs {
return None;
}
impl Step for Mingw {
- type Output = Option<PathBuf>;
+ type Output = Option<GeneratedTarball>;
const DEFAULT: bool = true;
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
///
/// This contains all the bits and pieces to run the MinGW Windows targets
/// without any extra installed software (e.g., we bundle gcc, libraries, etc).
- fn run(self, builder: &Builder<'_>) -> Option<PathBuf> {
+ fn run(self, builder: &Builder<'_>) -> Option<GeneratedTarball> {
let host = self.host;
if !host.contains("pc-windows-gnu") {
return None;
}
impl Step for Rustc {
- type Output = PathBuf;
+ type Output = GeneratedTarball;
const DEFAULT: bool = true;
const ONLY_HOSTS: bool = true;
}
/// Creates the `rustc` installer component.
- fn run(self, builder: &Builder<'_>) -> PathBuf {
+ fn run(self, builder: &Builder<'_>) -> GeneratedTarball {
let compiler = self.compiler;
let host = self.compiler.host;
}
impl Step for Std {
- type Output = Option<PathBuf>;
+ type Output = Option<GeneratedTarball>;
const DEFAULT: bool = true;
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
});
}
- fn run(self, builder: &Builder<'_>) -> Option<PathBuf> {
+ fn run(self, builder: &Builder<'_>) -> Option<GeneratedTarball> {
let compiler = self.compiler;
let target = self.target;
}
impl Step for RustcDev {
- type Output = Option<PathBuf>;
+ type Output = Option<GeneratedTarball>;
const DEFAULT: bool = true;
const ONLY_HOSTS: bool = true;
});
}
- fn run(self, builder: &Builder<'_>) -> Option<PathBuf> {
+ fn run(self, builder: &Builder<'_>) -> Option<GeneratedTarball> {
let compiler = self.compiler;
let target = self.target;
if skip_host_target_lib(builder, compiler) {
}
impl Step for Analysis {
- type Output = Option<PathBuf>;
+ type Output = Option<GeneratedTarball>;
const DEFAULT: bool = true;
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
}
/// Creates a tarball of save-analysis metadata, if available.
- fn run(self, builder: &Builder<'_>) -> Option<PathBuf> {
+ fn run(self, builder: &Builder<'_>) -> Option<GeneratedTarball> {
let compiler = self.compiler;
let target = self.target;
assert!(builder.config.extended);
impl Step for Src {
/// The output path of the src installer tarball
- type Output = PathBuf;
+ type Output = GeneratedTarball;
const DEFAULT: bool = true;
const ONLY_HOSTS: bool = true;
}
/// Creates the `rust-src` installer component
- fn run(self, builder: &Builder<'_>) -> PathBuf {
+ fn run(self, builder: &Builder<'_>) -> GeneratedTarball {
let tarball = Tarball::new_targetless(builder, "rust-src");
// A lot of tools expect the rust-src component to be entirely in this directory, so if you
impl Step for PlainSourceTarball {
/// Produces the location of the tarball generated
- type Output = PathBuf;
+ type Output = GeneratedTarball;
const DEFAULT: bool = true;
const ONLY_HOSTS: bool = true;
}
/// Creates the plain source tarball
- fn run(self, builder: &Builder<'_>) -> PathBuf {
+ fn run(self, builder: &Builder<'_>) -> GeneratedTarball {
let tarball = Tarball::new(builder, "rustc", "src");
let plain_dst_src = tarball.image_dir();
}
impl Step for Cargo {
- type Output = PathBuf;
+ type Output = GeneratedTarball;
const ONLY_HOSTS: bool = true;
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
});
}
- fn run(self, builder: &Builder<'_>) -> PathBuf {
+ fn run(self, builder: &Builder<'_>) -> GeneratedTarball {
let compiler = self.compiler;
let target = self.target;
}
impl Step for Rls {
- type Output = Option<PathBuf>;
+ type Output = Option<GeneratedTarball>;
const ONLY_HOSTS: bool = true;
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
});
}
- fn run(self, builder: &Builder<'_>) -> Option<PathBuf> {
+ fn run(self, builder: &Builder<'_>) -> Option<GeneratedTarball> {
let compiler = self.compiler;
let target = self.target;
assert!(builder.config.extended);
}
impl Step for RustAnalyzer {
- type Output = Option<PathBuf>;
+ type Output = Option<GeneratedTarball>;
const ONLY_HOSTS: bool = true;
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
});
}
- fn run(self, builder: &Builder<'_>) -> Option<PathBuf> {
+ fn run(self, builder: &Builder<'_>) -> Option<GeneratedTarball> {
let compiler = self.compiler;
let target = self.target;
assert!(builder.config.extended);
}
impl Step for Clippy {
- type Output = PathBuf;
+ type Output = GeneratedTarball;
const ONLY_HOSTS: bool = true;
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
});
}
- fn run(self, builder: &Builder<'_>) -> PathBuf {
+ fn run(self, builder: &Builder<'_>) -> GeneratedTarball {
let compiler = self.compiler;
let target = self.target;
assert!(builder.config.extended);
}
impl Step for Miri {
- type Output = Option<PathBuf>;
+ type Output = Option<GeneratedTarball>;
const ONLY_HOSTS: bool = true;
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
});
}
- fn run(self, builder: &Builder<'_>) -> Option<PathBuf> {
+ fn run(self, builder: &Builder<'_>) -> Option<GeneratedTarball> {
let compiler = self.compiler;
let target = self.target;
assert!(builder.config.extended);
}
impl Step for Rustfmt {
- type Output = Option<PathBuf>;
+ type Output = Option<GeneratedTarball>;
const ONLY_HOSTS: bool = true;
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
});
}
- fn run(self, builder: &Builder<'_>) -> Option<PathBuf> {
+ fn run(self, builder: &Builder<'_>) -> Option<GeneratedTarball> {
let compiler = self.compiler;
let target = self.target;
tarballs.push(mingw_installer.unwrap());
}
- let mut tarball = Tarball::new(builder, "rust", &target.triple);
- let work = tarball.persist_work_dir();
- tarball.combine(&tarballs);
+ let tarball = Tarball::new(builder, "rust", &target.triple);
+ let generated = tarball.combine(&tarballs);
let tmp = tmpdir(builder).join("combined-tarball");
+ let work = generated.work_dir();
let mut license = String::new();
license += &builder.read(&builder.src.join("COPYRIGHT"));
license += &builder.read(&builder.src.join("LICENSE-APACHE"));
license += &builder.read(&builder.src.join("LICENSE-MIT"));
- license.push_str("\n");
- license.push_str("\n");
+ license.push('\n');
+ license.push('\n');
let rtf = r"{\rtf1\ansi\deff0{\fonttbl{\f0\fnil\fcharset0 Arial;}}\nowwrap\fs18";
let mut rtf = rtf.to_string();
- rtf.push_str("\n");
+ rtf.push('\n');
for line in license.lines() {
rtf.push_str(line);
rtf.push_str("\\line ");
}
- rtf.push_str("}");
+ rtf.push('}');
fn filter(contents: &str, marker: &str) -> String {
let start = format!("tool-{}-start", marker);
}
impl Step for LlvmTools {
- type Output = Option<PathBuf>;
+ type Output = Option<GeneratedTarball>;
const ONLY_HOSTS: bool = true;
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
run.builder.ensure(LlvmTools { target: run.target });
}
- fn run(self, builder: &Builder<'_>) -> Option<PathBuf> {
+ fn run(self, builder: &Builder<'_>) -> Option<GeneratedTarball> {
let target = self.target;
assert!(builder.config.extended);
}
impl Step for RustDev {
- type Output = Option<PathBuf>;
+ type Output = Option<GeneratedTarball>;
const DEFAULT: bool = true;
const ONLY_HOSTS: bool = true;
run.builder.ensure(RustDev { target: run.target });
}
- fn run(self, builder: &Builder<'_>) -> Option<PathBuf> {
+ fn run(self, builder: &Builder<'_>) -> Option<GeneratedTarball> {
let target = self.target;
/* run only if llvm-config isn't used */
}
impl Step for BuildManifest {
- type Output = PathBuf;
+ type Output = GeneratedTarball;
const DEFAULT: bool = false;
const ONLY_HOSTS: bool = true;
run.builder.ensure(BuildManifest { target: run.target });
}
- fn run(self, builder: &Builder<'_>) -> PathBuf {
+ fn run(self, builder: &Builder<'_>) -> GeneratedTarball {
let build_manifest = builder.tool_exe(Tool::BuildManifest);
let tarball = Tarball::new(builder, "build-manifest", &self.target.triple);
}
impl Step for ReproducibleArtifacts {
- type Output = Option<PathBuf>;
+ type Output = Option<GeneratedTarball>;
const DEFAULT: bool = true;
const ONLY_HOSTS: bool = true;