Removed bootstrap asserts

src/bootstrap/bolt.rs

@@ -19,7 +19,12 @@ pub fn instrument_with_bolt_inplace(path: &Path) {
         .expect("Could not instrument artifact using BOLT");
 
     if !status.success() {
-        panic!("Could not instrument {} with BOLT, exit code {:?}", path.display(), status.code());
+        eprintln!(
+            "Could not instrument {} with BOLT, exit code {:?}",
+            path.display(),
+            status.code()
+        );
+        crate::detail_exit(1);
     }
 
     std::fs::copy(&instrumented_path, path).expect("Cannot copy instrumented artifact");
@@ -63,9 +68,9 @@ pub fn optimize_library_with_bolt_inplace(path: &Path, profile_path: &Path) {
         .expect("Could not optimize artifact using BOLT");
 
     if !status.success() {
-        panic!("Could not optimize {} with BOLT, exit code {:?}", path.display(), status.code());
+        eprintln!("Could not optimize {} with BOLT, exit code {:?}", path.display(), status.code());
+        crate::detail_exit(1);
     }
-
     std::fs::copy(&optimized_path, path).expect("Cannot copy optimized artifact");
     std::fs::remove_file(optimized_path).expect("Cannot delete optimized artifact");
 }

src/bootstrap/builder.rs

@@ -152,10 +152,14 @@ impl TaskPath {
             if let Some(str) = os_str.to_str() {
                 if let Some((found_kind, found_prefix)) = str.split_once("::") {
                     if found_kind.is_empty() {
-                        panic!("empty kind in task path {}", path.display());
+                        eprintln!("empty kind in task path {}", path.display());
+                        crate::detail_exit(1);
                     }
                     kind = Kind::parse(found_kind);
-                    assert!(kind.is_some());
+                    if !kind.is_some() {
+                        eprintln!("empty kind in task path {}", path.display());
+                        crate::detail_exit(1);
+                    }
                     path = Path::new(found_prefix).join(components.as_path());
                 }
             }
@@ -321,11 +325,10 @@ impl StepDescription {
 
         // sanity checks on rules
         for (desc, should_run) in v.iter().zip(&should_runs) {
-            assert!(
-                !should_run.paths.is_empty(),
-                "{:?} should have at least one pathset",
-                desc.name
-            );
+            if should_run.paths.is_empty() {
+                eprintln!("{:?} should have at least one pathset", desc.name);
+                crate::detail_exit(1);
+            }
         }
 
         if paths.is_empty() || builder.config.include_default_paths {
@@ -466,11 +469,12 @@ impl<'a> ShouldRun<'a> {
         // exceptional case for `Kind::Setup` because its `library`
         // and `compiler` options would otherwise naively match with
         // `compiler` and `library` folders respectively.
-        assert!(
-            self.kind == Kind::Setup || !self.builder.src.join(alias).exists(),
-            "use `builder.path()` for real paths: {}",
-            alias
-        );
+        match self.kind == Kind::Setup || !self.builder.src.join(alias).exists() {
+            true => {}
+            false => {
+                eprintln!("use `builder.path()` for real paths: {:?}", alias)
+            }
+        };
         self.paths.insert(PathSet::Set(
             std::iter::once(TaskPath { path: alias.into(), kind: Some(self.kind) }).collect(),
         ));
@@ -1197,7 +1201,10 @@ impl<'a> Builder<'a> {
                         out_dir.join(target.triple).join("doc")
                     }
                 }
-                _ => panic!("doc mode {:?} not expected", mode),
+                _ => {
+                    eprintln!("doc mode {:?} not expected", mode);
+                    crate::detail_exit(1);
+                }
             };
             let rustdoc = self.rustdoc(compiler);
             self.clear_if_dirty(&my_out, &rustdoc);
@@ -1945,7 +1952,8 @@ impl<'a> Builder<'a> {
                 for el in stack.iter().rev() {
                     out += &format!("\t{:?}\n", el);
                 }
-                panic!("{}", out);
+                eprintln!("{}", out);
+                crate::detail_exit(1);
             }
             if let Some(out) = self.cache.get(&step) {
                 self.verbose_than(1, &format!("{}c {:?}", "  ".repeat(stack.len()), step));

src/bootstrap/channel.rs

@@ -139,7 +139,10 @@ pub fn read_commit_info_file(root: &Path) -> Option<Info> {
                 sha: sha.to_owned(),
                 short_sha: short_sha.to_owned(),
             },
-            _ => panic!("the `git-comit-info` file is malformed"),
+            _ => {
+                eprintln!("the `git-comit-info` file is malformed");
+                crate::detail_exit(1);
+            }
         };
         Some(info)
     } else {

src/bootstrap/clean.rs

@@ -118,7 +118,8 @@ fn rm_rf(path: &Path) {
             if e.kind() == ErrorKind::NotFound {
                 return;
             }
-            panic!("failed to get metadata for file {}: {}", path.display(), e);
+            eprintln!("failed to get metadata for file {}: {}", path.display(), e);
+            crate::detail_exit(1);
         }
         Ok(metadata) => {
             if metadata.file_type().is_file() || metadata.file_type().is_symlink() {
@@ -180,11 +181,13 @@ where
                 if m.file_type().is_symlink() && path.is_dir() && fs::remove_dir(path).is_ok() {
                     return;
                 }
-                panic!("failed to {} {}: {}", desc, path.display(), e);
+                eprintln!("failed to {} {}: {}", desc, path.display(), e);
+                crate::detail_exit(1);
             });
         }
         Err(e) => {
-            panic!("failed to {} {}: {}", desc, path.display(), e);
+            eprintln!("failed to {} {}: {}", desc, path.display(), e);
+            crate::detail_exit(1);
         }
     }
 }

src/bootstrap/compile.rs

@@ -236,7 +236,8 @@ fn copy_self_contained_objects(
     // and link with them manually in the self-contained mode.
     if target.contains("musl") {
         let srcdir = builder.musl_libdir(target).unwrap_or_else(|| {
-            panic!("Target {:?} does not have a \"musl-libdir\" key", target.triple)
+            eprintln!("Target {:?} does not have a \"musl-libdir\" key", target.triple);
+            crate::detail_exit(1);
         });
         for &obj in &["libc.a", "crt1.o", "Scrt1.o", "rcrt1.o", "crti.o", "crtn.o"] {
             copy_and_stamp(
@@ -264,7 +265,8 @@ fn copy_self_contained_objects(
         let srcdir = builder
             .wasi_root(target)
             .unwrap_or_else(|| {
-                panic!("Target {:?} does not have a \"wasi-root\" key", target.triple)
+                eprintln!("Target {:?} does not have a \"wasi-root\" key", target.triple);
+                crate::detail_exit(1);
             })
             .join("lib/wasm32-wasi");
         for &obj in &["libc.a", "crt1-command.o", "crt1-reactor.o"] {
@@ -488,7 +490,10 @@ fn apple_darwin_update_library_name(library_path: &Path, new_name: &str) {
         .arg(library_path)
         .status()
         .expect("failed to execute `install_name_tool`");
-    assert!(status.success());
+    if !status.success() {
+        eprintln!("failed to execute `install_name_tool`");
+        crate::detail_exit(1);
+    };
 }
 
 fn apple_darwin_sign_file(file_path: &Path) {
@@ -499,7 +504,10 @@ fn apple_darwin_sign_file(file_path: &Path) {
         .arg(file_path)
         .status()
         .expect("failed to execute `codesign`");
-    assert!(status.success());
+    if !status.success() {
+        eprintln!("failed to execute `codesign`");
+        crate::detail_exit(1);
+    }
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
@@ -662,7 +670,8 @@ impl Step for Rustc {
         if builder.config.rust_profile_use.is_some()
             && builder.config.rust_profile_generate.is_some()
         {
-            panic!("Cannot use and generate PGO profiles at the same time");
+            eprintln!("Cannot use and generate PGO profiles at the same time");
+            crate::detail_exit(1);
         }
 
         // With LLD, we can use ICF (identical code folding) to reduce the executable size
@@ -1020,14 +1029,18 @@ impl Step for CodegenBackend {
         });
         let codegen_backend = match files.next() {
             Some(f) => f,
-            None => panic!("no dylibs built for codegen backend?"),
+            None => {
+                eprintln!("no dylibs built for codegen backend?");
+                crate::detail_exit(1);
+            }
         };
         if let Some(f) = files.next() {
-            panic!(
+            eprintln!(
                 "codegen backend built two dylibs:\n{}\n{}",
                 codegen_backend.display(),
                 f.display()
             );
+            crate::detail_exit(1);
         }
         let stamp = codegen_backend_stamp(builder, compiler, target, backend);
         let codegen_backend = codegen_backend.to_str().unwrap();
@@ -1567,7 +1580,10 @@ pub fn run_cargo(
         });
         let path_to_add = match max {
             Some(triple) => triple.0.to_str().unwrap(),
-            None => panic!("no output generated for {:?} {:?}", prefix, extension),
+            None => {
+                eprintln!("no output generated for {:?} {:?}", prefix, extension);
+                crate::detail_exit(1);
+            }
         };
         if is_dylib(path_to_add) {
             let candidate = format!("{}.lib", path_to_add);
@@ -1625,7 +1641,10 @@ pub fn stream_cargo(
     builder.verbose(&format!("running: {:?}", cargo));
     let mut child = match cargo.spawn() {
         Ok(child) => child,
-        Err(e) => panic!("failed to execute command: {:?}\nerror: {}", cargo, e),
+        Err(e) => {
+            eprintln!("failed to execute command: {:?}\nerror: {}", cargo, e);
+            crate::detail_exit(1);
+        }
     };
 
     // Spawn Cargo slurping up its JSON output. We'll start building up the

src/bootstrap/config.rs

@@ -28,11 +28,10 @@ use serde::{Deserialize, Deserializer};
 
 macro_rules! check_ci_llvm {
     ($name:expr) => {
-        assert!(
-            $name.is_none(),
-            "setting {} is incompatible with download-ci-llvm.",
-            stringify!($name)
-        );
+        if !$name.is_none() {
+            eprintln!("setting {} is incompatible with download-ci-llvm.", stringify!($name));
+            $crate::detail_exit(1);
+        }
     };
 }
 
@@ -504,7 +503,10 @@ impl Merge for TomlConfig {
         do_merge(&mut self.llvm, llvm);
         do_merge(&mut self.rust, rust);
         do_merge(&mut self.dist, dist);
-        assert!(target.is_none(), "merging target-specific config is not currently supported");
+        if !target.is_none() {
+            eprintln!("merging target-specific config is not currently supported");
+            crate::detail_exit(1);
+        }
     }
 }
 
@@ -1189,7 +1191,13 @@ impl Config {
             let asserts = llvm_assertions.unwrap_or(false);
             config.llvm_from_ci = match llvm.download_ci_llvm {
                 Some(StringOrBool::String(s)) => {
-                    assert!(s == "if-available", "unknown option `{}` for download-ci-llvm", s);
+                    match s == "if-available" {
+                        false => {
+                            eprintln!("unknown option `{}` for download-ci-llvm", s);
+                            crate::detail_exit(1);
+                        }
+                        true => {}
+                    };
                     crate::native::is_ci_llvm_available(&config, asserts)
                 }
                 Some(StringOrBool::Bool(b)) => b,
@@ -1458,7 +1466,7 @@ impl Config {
                     if let Err(version) = version {
                         eprintln!("reading {}/src/version failed: {:?}", src, version);
                     }
-                    panic!();
+                    crate::detail_exit(1);
                 }
             }
         };
@@ -1498,7 +1506,9 @@ impl Config {
 
     /// The absolute path to the downloaded LLVM artifacts.
     pub(crate) fn ci_llvm_root(&self) -> PathBuf {
-        assert!(self.llvm_from_ci);
+        if !self.llvm_from_ci {
+            crate::detail_exit(1);
+        }
         self.out.join(&*self.build.triple).join("ci-llvm")
     }
 
@@ -1628,7 +1638,8 @@ impl Config {
             Some(StringOrBool::Bool(true)) => false,
             Some(StringOrBool::String(s)) if s == "if-unchanged" => true,
             Some(StringOrBool::String(other)) => {
-                panic!("unrecognized option for download-rustc: {}", other)
+                eprintln!("unrecognized option for download-rustc: {}", other);
+                crate::detail_exit(1);
             }
         };
 

src/bootstrap/dist.rs

@@ -158,7 +158,8 @@ fn find_files(files: &[&str], path: &[PathBuf]) -> Vec<PathBuf> {
         if let Some(file_path) = file_path {
             found.push(file_path);
         } else {
-            panic!("Could not find '{}' in {:?}", file, path);
+            eprintln!("Could not find '{}' in {:?}", file, path);
+            crate::detail_exit(1);
         }
     }
 
@@ -597,7 +598,8 @@ fn verify_uefi_rlib_format(builder: &Builder<'_>, target: TargetSelection, stamp
 
             if !is_coff {
                 let member_name = String::from_utf8_lossy(member.name());
-                panic!("member {} in {} is not COFF", member_name, path.display());
+                eprintln!("member {} in {} is not COFF", member_name, path.display());
+                crate::detail_exit(1);
             }
         }
     }

src/bootstrap/doc.rs

@@ -566,10 +566,11 @@ fn doc_std(
         format.as_str()
     ));
     if builder.no_std(target) == Some(true) {
-        panic!(
+        eprintln!(
             "building std documentation for no_std target {target} is not supported\n\
              Set `docs = false` in the config to disable documentation."
         );
+        crate::detail_exit(1);
     }
     let compiler = builder.compiler(stage, builder.config.build);
 

src/bootstrap/download.rs

@@ -37,7 +37,10 @@ impl Config {
         if self.dry_run() {
             return;
         }
-        fs::remove_file(f).unwrap_or_else(|_| panic!("failed to remove {:?}", f));
+        fs::remove_file(f).unwrap_or_else(|_| {
+            eprintln!("failed to remove {:?}", f);
+            crate::detail_exit(1);
+        });
     }
 
     /// Create a temporary directory in `out` and return its path.
@@ -200,8 +203,14 @@ impl Config {
             Some("http") | Some("https") => {
                 self.download_http_with_retries(&tempfile, url, help_on_error)
             }
-            Some(other) => panic!("unsupported protocol {other} in {url}"),
-            None => panic!("no protocol in {url}"),
+            Some(other) => {
+                eprintln!("unsupported protocol {} in {}", other, url);
+                crate::detail_exit(1);
+            }
+            None => {
+                eprintln!("no protocol in {}", url);
+                crate::detail_exit(1);
+            }
         }
         t!(std::fs::rename(&tempfile, dest_path));
     }
@@ -282,7 +291,8 @@ impl Config {
             let dst_path = dst.join(short_path);
             self.verbose(&format!("extracting {} to {}", original_path.display(), dst.display()));
             if !t!(member.unpack_in(dst)) {
-                panic!("path traversal attack ??");
+                eprintln!("path traversal attack ??");
+                crate::detail_exit(1);
             }
             let src_path = dst.join(original_path);
             if src_path.is_dir() && dst_path.exists() {
@@ -471,7 +481,8 @@ impl Config {
         self.download_file(&format!("{base_url}/{url}"), &tarball, "");
         if let Some(sha256) = checksum {
             if !self.verify(&tarball, sha256) {
-                panic!("failed to verify {}", tarball.display());
+                eprintln!("failed to verify {}", tarball.display());
+                crate::detail_exit(1);
             }
         }