rustc_target: Add TargetOption.check_environment

This function gets called after a Target is created, and can be used to verify
that the environment is suitable for building for a given target. E.g. it's a
place to check for environment variables, executables in the path, libraries
required for linking, and so on.

If the check fails, the user gets a simple error message instead of a backtrace
culminating in a message to file a bug against the Rust team.

Author: tnewsome-lynx

Diff for: compiler/rustc_driver_impl/src/lib.rs

@@ -271,7 +271,7 @@ pub fn run_compiler(at_args: &[String], callbacks: &mut (dyn Callbacks + Send))
 
     let registered_lints = config.register_lints.is_some();
 
-    interface::run_compiler(config, |compiler| {
+    if let Err(error_msg) = interface::run_compiler(config, |compiler| {
         let sess = &compiler.sess;
         let codegen_backend = &*compiler.codegen_backend;
 
@@ -379,7 +379,9 @@ pub fn run_compiler(at_args: &[String], callbacks: &mut (dyn Callbacks + Send))
         if let Some(linker) = linker {
             linker.link(sess, codegen_backend);
         }
-    })
+    }) {
+        eprintln!("Error: {error_msg}");
+    }
 }
 
 fn dump_feature_usage_metrics(tcxt: TyCtxt<'_>, metrics_dir: &Path) {

Diff for: compiler/rustc_interface/src/interface.rs

@@ -378,7 +378,10 @@ pub(crate) fn initialize_checked_jobserver(early_dcx: &EarlyDiagCtxt) {
 
 // JUSTIFICATION: before session exists, only config
 #[allow(rustc::bad_opt_access)]
-pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Send) -> R {
+pub fn run_compiler<R: Send>(
+    config: Config,
+    f: impl FnOnce(&Compiler) -> R + Send,
+) -> result::Result<R, String> {
     trace!("run_compiler");
 
     // Set parallel mode before thread pool creation, which will create `Lock`s.
@@ -392,12 +395,13 @@ pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Se
 
     let sysroot = filesearch::materialize_sysroot(config.opts.maybe_sysroot.clone());
     let target = config::build_target_config(&early_dcx, &config.opts.target_triple, &sysroot);
+    target.options.check_environment()?;
     let file_loader = config.file_loader.unwrap_or_else(|| Box::new(RealFileLoader));
     let path_mapping = config.opts.file_path_mapping();
     let hash_kind = config.opts.unstable_opts.src_hash_algorithm(&target);
     let checksum_hash_kind = config.opts.unstable_opts.checksum_hash_algorithm();
 
-    util::run_in_thread_pool_with_globals(
+    Ok(util::run_in_thread_pool_with_globals(
         &early_dcx,
         config.opts.edition,
         config.opts.unstable_opts.threads,
@@ -537,7 +541,7 @@ pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Se
 
             res
         },
-    )
+    ))
 }
 
 pub fn try_print_query_stack(

Diff for: compiler/rustc_target/src/spec/json.rs

@@ -261,6 +261,15 @@ impl Target {
                     Some(Ok(()))
                 })).unwrap_or(Ok(()))
             } );
+            ($key_name:ident, CheckEnvironment) => ( {
+                obj.remove("check-environment").and_then(|o| o.as_str().and_then(|s| {
+                    match s.parse::<super::CheckEnvironment>() {
+                        Ok(support) => base.check_environment = support,
+                        _ => return Some(Err(format!("'{s}' is not a valid value for check-environment."))),
+                    }
+                    Some(Ok(()))
+                })).unwrap_or(Ok(()))
+            } );
             ($key_name:ident, list) => ( {
                 let name = (stringify!($key_name)).replace("_", "-");
                 if let Some(j) = obj.remove(&name) {
@@ -655,6 +664,7 @@ impl Target {
         key!(entry_name);
         key!(entry_abi, Conv)?;
         key!(supports_xray, bool);
+        key!(check_environment, CheckEnvironment)?;
 
         base.update_from_cli();
         base.check_consistency(TargetKind::Json)?;
@@ -834,6 +844,7 @@ impl ToJson for Target {
         target_option_val!(entry_name);
         target_option_val!(entry_abi);
         target_option_val!(supports_xray);
+        target_option_val!(check_environment);
 
         // Serializing `-Clink-self-contained` needs a dynamic key to support the
         // backwards-compatible variants.

Diff for: compiler/rustc_target/src/spec/mod.rs

@@ -933,6 +933,27 @@ impl ToJson for SmallDataThresholdSupport {
     }
 }
 
+#[derive(Clone, Debug, PartialEq, Hash)]
+pub enum CheckEnvironment {
+    None,
+}
+
+impl FromStr for CheckEnvironment {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if s == "none" { Ok(Self::None) } else { Err(()) }
+    }
+}
+
+impl ToJson for CheckEnvironment {
+    fn to_json(&self) -> Value {
+        match self {
+            Self::None => "none".to_json(),
+        }
+    }
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Hash)]
 pub enum MergeFunctions {
     Disabled,
@@ -2657,6 +2678,14 @@ pub struct TargetOptions {
 
     /// Whether the targets supports -Z small-data-threshold
     small_data_threshold_support: SmallDataThresholdSupport,
+
+    /// Function to check that the environment is correct for compiling for this
+    /// target. E.g. it can check that environment variables are set, that the
+    /// right linker is available, that the right libraries are available, and
+    /// so on.
+    /// We don't put the function in here directly because this structure can be
+    /// converted to/from json and functions can't do that.
+    pub check_environment: CheckEnvironment,
 }
 
 /// Add arguments for the given flavor and also for its "twin" flavors
@@ -2759,6 +2788,12 @@ impl TargetOptions {
                 .collect();
         }
     }
+
+    pub fn check_environment(&self) -> Result<(), String> {
+        match self.check_environment {
+            CheckEnvironment::None => Ok(()),
+        }
+    }
 }
 
 impl Default for TargetOptions {
@@ -2884,6 +2919,7 @@ impl Default for TargetOptions {
             entry_abi: Conv::C,
             supports_xray: false,
             small_data_threshold_support: SmallDataThresholdSupport::DefaultForArch,
+            check_environment: CheckEnvironment::None,
         }
     }
 }

Diff for: src/librustdoc/doctest.rs

@@ -248,7 +248,8 @@ pub(crate) fn run(dcx: DiagCtxtHandle<'_>, input: Input, options: RustdocOptions
         compiler.sess.dcx().abort_if_errors();
 
         collector
-    });
+    })
+    .unwrap();
 
     let CreateRunnableDocTests {
         standalone_tests,

Diff for: src/librustdoc/lib.rs

@@ -834,7 +834,8 @@ fn main_args(early_dcx: &mut EarlyDiagCtxt, at_args: &[String]) {
                 dcx,
                 interface::run_compiler(config, |_compiler| {
                     markdown::render_and_write(&md_input, render_options, edition)
-                }),
+                })
+                .unwrap(),
             );
         }
         (false, None) => {}
@@ -908,4 +909,5 @@ fn main_args(early_dcx: &mut EarlyDiagCtxt, at_args: &[String]) {
             }
         })
     })
+    .unwrap()
 }