-//! Build a dist manifest, hash and sign everything.
-//! This gets called by `promote-release`
-//! (https://github.com/rust-lang/rust-central-station/tree/master/promote-release)
-//! via `x.py dist hash-and-sign`; the cmdline arguments are set up
-//! by rustbuild (in `src/bootstrap/dist.rs`).
+#![doc = include_str!("../README.md")]
mod checksum;
mod manifest;
"aarch64-unknown-none",
"aarch64-unknown-none-softfloat",
"aarch64-unknown-redox",
+ "aarch64-unknown-uefi",
"arm-linux-androideabi",
"arm-unknown-linux-gnueabi",
"arm-unknown-linux-gnueabihf",
"i686-unknown-freebsd",
"i686-unknown-linux-gnu",
"i686-unknown-linux-musl",
+ "i686-unknown-uefi",
"m68k-unknown-linux-gnu",
"mips-unknown-linux-gnu",
"mips-unknown-linux-musl",
"x86_64-unknown-none",
"x86_64-unknown-redox",
"x86_64-unknown-hermit",
+ "x86_64-unknown-uefi",
];
/// This allows the manifest to contain rust-docs for hosts that don't build
static MINGW: &[&str] = &["i686-pc-windows-gnu", "x86_64-pc-windows-gnu"];
-static NIGHTLY_ONLY_COMPONENTS: &[&str] = &["miri-preview", "rust-docs-json-preview"];
+static NIGHTLY_ONLY_COMPONENTS: &[PkgType] = &[PkgType::Miri, PkgType::JsonDocs];
macro_rules! t {
($e:expr) => {
}
fn add_packages_to(&mut self, manifest: &mut Manifest) {
- macro_rules! package {
- ($name:expr, $targets:expr) => {
- self.package($name, &mut manifest.pkg, $targets, &[])
- };
+ for pkg in PkgType::all() {
+ self.package(pkg, &mut manifest.pkg);
}
- package!("rustc", HOSTS);
- package!("rustc-dev", HOSTS);
- package!("reproducible-artifacts", HOSTS);
- package!("rustc-docs", HOSTS);
- package!("cargo", HOSTS);
- package!("rust-mingw", MINGW);
- package!("rust-std", TARGETS);
- self.package("rust-docs", &mut manifest.pkg, HOSTS, DOCS_FALLBACK);
- self.package("rust-docs-json-preview", &mut manifest.pkg, HOSTS, DOCS_FALLBACK);
- package!("rust-src", &["*"]);
- package!("rls-preview", HOSTS);
- package!("rust-analyzer-preview", HOSTS);
- package!("clippy-preview", HOSTS);
- package!("miri-preview", HOSTS);
- package!("rustfmt-preview", HOSTS);
- package!("rust-analysis", TARGETS);
- package!("llvm-tools-preview", TARGETS);
}
fn add_artifacts_to(&mut self, manifest: &mut Manifest) {
}
fn add_profiles_to(&mut self, manifest: &mut Manifest) {
- let mut profile = |name, pkgs| self.profile(name, &mut manifest.profiles, pkgs);
- profile("minimal", &["rustc", "cargo", "rust-std", "rust-mingw"]);
- profile(
- "default",
- &[
- "rustc",
- "cargo",
- "rust-std",
- "rust-mingw",
- "rust-docs",
- "rustfmt-preview",
- "clippy-preview",
- ],
- );
- profile(
- "complete",
- &[
- "rustc",
- "cargo",
- "rust-std",
- "rust-mingw",
- "rust-docs",
- "rustfmt-preview",
- "clippy-preview",
- "rls-preview",
- "rust-analyzer-preview",
- "rust-src",
- "llvm-tools-preview",
- "rust-analysis",
- "miri-preview",
- ],
- );
+ use PkgType::*;
+
+ let mut profile = |name, pkgs: &_| self.profile(name, &mut manifest.profiles, pkgs);
+
+ // Use a Vec here to make sure we don't exclude any components in an earlier profile.
+ let minimal = vec![Rustc, Cargo, RustStd, RustMingw];
+ profile("minimal", &minimal);
+
+ let mut default = minimal;
+ default.extend([HtmlDocs, Rustfmt, Clippy]);
+ profile("default", &default);
+
+ // NOTE: this profile is effectively deprecated; do not add new components to it.
+ let mut complete = default;
+ complete.extend([Rls, RustAnalyzer, RustSrc, LlvmTools, RustAnalysis, Miri]);
+ profile("complete", &complete);
// The compiler libraries are not stable for end users, and they're also huge, so we only
// `rustc-dev` for nightly users, and only in the "complete" profile. It's still possible
// for users to install the additional component manually, if needed.
if self.versions.channel() == "nightly" {
- self.extend_profile("complete", &mut manifest.profiles, &["rustc-dev"]);
+ self.extend_profile("complete", &mut manifest.profiles, &[RustcDev]);
// Do not include the rustc-docs component for now, as it causes
// conflicts with the rust-docs component when installed. See
// #75833.
let mut rename = |from: &str, to: &str| {
manifest.renames.insert(from.to_owned(), Rename { to: to.to_owned() })
};
- rename("rls", "rls-preview");
- rename("rustfmt", "rustfmt-preview");
- rename("clippy", "clippy-preview");
- rename("miri", "miri-preview");
- rename("rust-docs-json", "rust-docs-json-preview");
- rename("rust-analyzer", "rust-analyzer-preview");
+ for pkg in PkgType::all() {
+ if pkg.is_preview() {
+ rename(pkg.tarball_component_name(), &pkg.manifest_component_name());
+ }
+ }
}
fn rust_package(&mut self, manifest: &Manifest) -> Package {
let mut components = Vec::new();
let mut extensions = Vec::new();
- let host_component = |pkg| Component::from_str(pkg, host);
-
- // rustc/rust-std/cargo/docs are all required,
- // and so is rust-mingw if it's available for the target.
- components.extend(vec![
- host_component("rustc"),
- host_component("rust-std"),
- host_component("cargo"),
- host_component("rust-docs"),
- ]);
- if host.contains("pc-windows-gnu") {
- components.push(host_component("rust-mingw"));
- }
+ let host_component = |pkg: &_| Component::from_pkg(pkg, host);
- // Tools are always present in the manifest,
- // but might be marked as unavailable if they weren't built.
- extensions.extend(vec![
- host_component("clippy-preview"),
- host_component("miri-preview"),
- host_component("rls-preview"),
- host_component("rust-analyzer-preview"),
- host_component("rustfmt-preview"),
- host_component("llvm-tools-preview"),
- host_component("rust-analysis"),
- host_component("rust-docs-json-preview"),
- ]);
-
- extensions.extend(
- TARGETS
- .iter()
- .filter(|&&target| target != host)
- .map(|target| Component::from_str("rust-std", target)),
- );
- extensions.extend(HOSTS.iter().map(|target| Component::from_str("rustc-dev", target)));
- extensions.extend(HOSTS.iter().map(|target| Component::from_str("rustc-docs", target)));
- extensions.push(Component::from_str("rust-src", "*"));
+ for pkg in PkgType::all() {
+ match pkg {
+ // rustc/rust-std/cargo/docs are all required
+ PkgType::Rustc | PkgType::Cargo | PkgType::HtmlDocs => {
+ components.push(host_component(pkg));
+ }
+ PkgType::RustStd => {
+ components.push(host_component(pkg));
+ extensions.extend(
+ TARGETS
+ .iter()
+ .filter(|&&target| target != host)
+ .map(|target| Component::from_pkg(pkg, target)),
+ );
+ }
+ // so is rust-mingw if it's available for the target
+ PkgType::RustMingw => {
+ if host.contains("pc-windows-gnu") {
+ components.push(host_component(pkg));
+ }
+ }
+ // Tools are always present in the manifest,
+ // but might be marked as unavailable if they weren't built.
+ PkgType::Clippy
+ | PkgType::Miri
+ | PkgType::Rls
+ | PkgType::RustAnalyzer
+ | PkgType::Rustfmt
+ | PkgType::LlvmTools
+ | PkgType::RustAnalysis
+ | PkgType::JsonDocs => {
+ extensions.push(host_component(pkg));
+ }
+ PkgType::RustcDev | PkgType::RustcDocs => {
+ extensions.extend(HOSTS.iter().map(|target| Component::from_pkg(pkg, target)));
+ }
+ PkgType::RustSrc => {
+ extensions.push(Component::from_pkg(pkg, "*"));
+ }
+ PkgType::Rust => {}
+ // NOTE: this is intentional, these artifacts aren't intended to be used with rustup
+ PkgType::ReproducibleArtifacts => {}
+ }
+ }
// If the components/extensions don't actually exist for this
// particular host/target combination then nix it entirely from our
&mut self,
profile_name: &str,
dst: &mut BTreeMap<String, Vec<String>>,
- pkgs: &[&str],
+ pkgs: &[PkgType],
) {
- dst.insert(profile_name.to_owned(), pkgs.iter().map(|s| (*s).to_owned()).collect());
+ dst.insert(
+ profile_name.to_owned(),
+ pkgs.iter().map(|s| s.manifest_component_name()).collect(),
+ );
}
fn extend_profile(
&mut self,
profile_name: &str,
dst: &mut BTreeMap<String, Vec<String>>,
- pkgs: &[&str],
+ pkgs: &[PkgType],
) {
dst.get_mut(profile_name)
.expect("existing profile")
- .extend(pkgs.iter().map(|s| (*s).to_owned()));
+ .extend(pkgs.iter().map(|s| s.manifest_component_name()));
}
- fn package(
- &mut self,
- pkgname: &str,
- dst: &mut BTreeMap<String, Package>,
- targets: &[&str],
- fallback: &[(&str, &str)],
- ) {
- let version_info = self
- .versions
- .version(&PkgType::from_component(pkgname))
- .expect("failed to load package version");
+ fn package(&mut self, pkg: &PkgType, dst: &mut BTreeMap<String, Package>) {
+ if *pkg == PkgType::Rust {
+ // This is handled specially by `rust_package` later.
+ // Order is important, so don't call `rust_package` here.
+ return;
+ }
+
+ let fallback = if pkg.use_docs_fallback() { DOCS_FALLBACK } else { &[] };
+ let version_info = self.versions.version(&pkg).expect("failed to load package version");
let mut is_present = version_info.present;
// Never ship nightly-only components for other trains.
- if self.versions.channel() != "nightly" && NIGHTLY_ONLY_COMPONENTS.contains(&pkgname) {
+ if self.versions.channel() != "nightly" && NIGHTLY_ONLY_COMPONENTS.contains(&pkg) {
is_present = false; // Pretend the component is entirely missing.
}
macro_rules! tarball_name {
($target_name:expr) => {
- self.versions.tarball_name(&PkgType::from_component(pkgname), $target_name).unwrap()
+ self.versions.tarball_name(pkg, $target_name).unwrap()
};
}
let mut target_from_compressed_tar = |target_name| {
Target::unavailable()
};
- let targets = targets
+ let targets = pkg
+ .targets()
.iter()
.map(|name| {
let target = if is_present {
.collect();
dst.insert(
- pkgname.to_string(),
+ pkg.manifest_component_name(),
Package {
version: version_info.version.unwrap_or_default(),
git_commit_hash: version_info.git_commit,
projects / rustc.git / blobdiff