Change:
Edit: The total Rust archive size has intensified recently. Is this a regression caused by ? cc (for the PR), (infra team)
modify labels: T-infra
Error: Label I-heavy can only be set by Rust team members Please let know if you're having trouble with this bot.
Yes, this is an expected regression by
See also
This contains justification of the change: This contains suggestions on decreasing the size: There are big in compilation speed, but mostly only startup improvements (relative speedup increasing the smaller the crate is), which makes sense if you read the comment by I've linked above: there is less work to do at load time of the binary.
My own suggestion: - reproduced below: We would have to either include MIR for everything and codegen at the end (potentially subopyimal) or just throw away the and somehow require the final crate to be linked in order to use anything from the component crates. For the latter, it could be as simple as a check like "at least one of the dependency crates must claim to contain each symbol referenced and be linkable".

Discussion:
dist::Rustc, dist::DebuggerScripts, dist::Std, <ins> dist::RustcDev, </ins> dist::Analysis, dist::Src, dist::PlainSourceTarball,

} } <ins> fn skip_host_target_lib(builder: &Builder<'_>, compiler: Compiler) -> bool { // The only true set of target libraries came from the build triple, so // let's reduce redundant work by only producing archives from that host. if compiler.host != builder.config.build { builder.info("tskipping, not a build host"); true } else { false } } /// Copy stamped files into an image's `target/lib` directory. fn copy_target_libs(builder: &Builder<'_>, target: &str, image: &Path, stamp: &Path) { let dst = image.join("lib/rustlib").join(target).join("lib"); t!(fs::create_dir_all(&dst)); for (path, host) in builder.read_stamp_file(stamp) { if !host || builder.config.build == target { builder.copy(&path, &dst.join(path.file_name().unwrap())); } } } </ins> #[derive(Debug, PartialOrd, Ord, Copy, Clone, Hash, PartialEq, Eq)] pub struct Std { pub compiler: Compiler,

let target = self.target; let name = pkgname(builder, "rust-std"); <del> // The only true set of target libraries came from the build triple, so // let's reduce redundant work by only producing archives from that host. if compiler.host != builder.config.build { builder.info("tskipping, not a build host"); return distdir(builder).join(format!("{}-{}.tar.gz", name, target)); </del> <ins> let archive = distdir(builder).join(format!("{}-{}.tar.gz", name, target)); if skip_host_target_lib(builder, compiler) { return archive; </ins> } <del> // We want to package up as many target libraries as possible // for the `rust-std` package, so if this is a host target we // depend on librustc and otherwise we just depend on libtest. if builder.hosts.iter().any(|t| t == target) { builder.ensure(compile::Rustc { compiler, target }); } else { builder.ensure(compile::Std { compiler, target }); } </del> <ins> builder.ensure(compile::Std { compiler, target }); </ins> let image = tmpdir(builder).join(format!("{}-{}-image", name, target)); let _ = fs::remove_dir_all(&image); <del> let dst = image.join("lib/rustlib").join(target); t!(fs::create_dir_all(&dst)); let mut src = builder.sysroot_libdir(compiler, target).to_path_buf(); src.pop(); // Remove the trailing /lib folder from the sysroot_libdir builder.cp_filtered(&src, &dst, &|path| { if let Some(name) = path.file_name().and_then(|s| s.to_str()) { if name == builder.config.rust_codegen_backends_dir.as_str() { return false } if name == "bin" { return false } if name.contains("LLVM") { return false } } true }); </del> <ins> let compiler_to_use = builder.compiler_for(compiler.stage, compiler.host, target); let stamp = compile::libstd_stamp(builder, compiler_to_use, target); copy_target_libs(builder, &target, &image, &stamp); </ins> let mut cmd = rust_installer(builder); cmd.arg("generate")

let _time = timeit(builder); builder.run(&mut cmd); builder.remove_dir(&image); <del> distdir(builder).join(format!("{}-{}.tar.gz", name, target)) </del> <ins> archive } } #[derive(Debug, PartialOrd, Ord, Copy, Clone, Hash, PartialEq, Eq)] pub struct RustcDev { pub compiler: Compiler, pub target: Interned<String>, } impl Step for RustcDev { type Output = PathBuf; const DEFAULT: bool = true; const ONLY_HOSTS: bool = true; fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path("rustc-dev") } fn make_run(run: RunConfig<'_>) { run.builder.ensure(RustcDev { compiler: run.builder.compiler_for( run.builder.top_stage, run.builder.config.build, run.target, ), target: run.target, }); } fn run(self, builder: &Builder<'_>) -> PathBuf { let compiler = self.compiler; let target = self.target; let name = pkgname(builder, "rustc-dev"); let archive = distdir(builder).join(format!("{}-{}.tar.gz", name, target)); if skip_host_target_lib(builder, compiler) { return archive; } builder.ensure(compile::Rustc { compiler, target }); let image = tmpdir(builder).join(format!("{}-{}-image", name, target)); let _ = fs::remove_dir_all(&image); let compiler_to_use = builder.compiler_for(compiler.stage, compiler.host, target); let stamp = compile::librustc_stamp(builder, compiler_to_use, target); copy_target_libs(builder, &target, &image, &stamp); let mut cmd = rust_installer(builder); cmd.arg("generate") .arg("--product-name=Rust") .arg("--rel-manifest-dir=rustlib") .arg("--success-message=Rust-is-ready-to-develop.") .arg("--image-dir").arg(&image) .arg("--work-dir").arg(&tmpdir(builder)) .arg("--output-dir").arg(&distdir(builder)) .arg(format!("--package-name={}-{}", name, target)) .arg(format!("--component-name=rustc-dev-{}", target)) .arg("--legacy-manifest-dirs=rustlib,cargo"); builder.info(&format!("Dist rustc-dev stage{} ({} -> {})", compiler.stage, &compiler.host, target)); let _time = timeit(builder); builder.run(&mut cmd); builder.remove_dir(&image); archive </ins> } }

fn add_packages_to(&mut self, manifest: &mut Manifest) { let mut package = |name, targets| self.package(name, &mut manifest.pkg, targets); package("rustc", HOSTS); <ins> package("rustc-dev", HOSTS); </ins> package("cargo", HOSTS); package("rust-mingw", MINGW); package("rust-std", TARGETS);

"rls-preview", "rust-src", "llvm-tools-preview", "lldb-preview", "rust-analysis", "miri-preview" ]); <ins> // The compiler libraries are not stable for end users, but `rustc-dev` was only recently // split out of `rust-std`. We'll include it by default as a transition for nightly users. if self.rust_release == "nightly" { self.extend_profile("default", &mut manifest.profiles, &["rustc-dev"]); self.extend_profile("complete", &mut manifest.profiles, &["rustc-dev"]); } </ins> } fn add_renames_to(&self, manifest: &mut Manifest) {

components.push(host_component("rust-mingw")); } <ins> // The compiler libraries are not stable for end users, but `rustc-dev` was only recently // split out of `rust-std`. We'll include it by default as a transition for nightly users, // but ship it as an optional component on the beta and stable channels. if self.rust_release == "nightly" { components.push(host_component("rustc-dev")); } else { extensions.push(host_component("rustc-dev")); } </ins> // Tools are always present in the manifest, // but might be marked as unavailable if they weren't built. extensions.extend(vec![

.filter(|&&target| target != host) .map(|target| Component::from_str("rust-std", target)) ); <ins> extensions.extend( HOSTS.iter() .filter(|&&target| target != host) .map(|target| Component::from_str("rustc-dev", target)) ); </ins> extensions.push(Component::from_str("rust-src", "*")); // If the components/extensions don't actually exist for this

dst.insert(profile_name.to_owned(), pkgs.iter().map(|s| (*s).to_owned()).collect()); } <ins> fn extend_profile(&mut self, profile_name: &str, dst: &mut BTreeMap<String, Vec<String>>, pkgs: &[&str]) { dst.get_mut(profile_name).expect("existing profile") .extend(pkgs.iter().map(|s| (*s).to_owned())); } </ins> fn package(&mut self, pkgname: &str, dst: &mut BTreeMap<String, Package>,