Add TyCtx::env_var

Author: madsmtm

compiler/rustc_codegen_ssa/src/lib.rs

@@ -35,6 +35,7 @@ use rustc_middle::dep_graph::WorkProduct;
 use rustc_middle::middle::debugger_visualizer::DebuggerVisualizerFile;
 use rustc_middle::middle::dependency_format::Dependencies;
 use rustc_middle::middle::exported_symbols::SymbolExportKind;
+use rustc_middle::ty::TyCtxt;
 use rustc_middle::util::Providers;
 use rustc_serialize::opaque::{FileEncoder, MemDecoder};
 use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
@@ -302,3 +303,10 @@ impl CodegenResults {
         Ok((codegen_results, outputs))
     }
 }
+
+/// Tell the `TyCtxt` the environment variables that codegen and linking are
+/// going to need.
+pub fn register_environment_variables(_tcx: TyCtxt<'_>) {
+    // FIXME(madsmtm): Add deployment target and SDK root
+    // https://github.com/rust-lang/rust/pull/129342
+}

compiler/rustc_errors/src/diagnostic_impls.rs

@@ -242,6 +242,12 @@ impl IntoDiagArg for std::ffi::CString {
     }
 }
 
+impl IntoDiagArg for std::ffi::OsString {
+    fn into_diag_arg(self) -> DiagArgValue {
+        DiagArgValue::Str(Cow::Owned(self.to_string_lossy().into_owned()))
+    }
+}
+
 impl IntoDiagArg for rustc_data_structures::small_c_str::SmallCStr {
     fn into_diag_arg(self) -> DiagArgValue {
         DiagArgValue::Str(Cow::Owned(self.to_string_lossy().into_owned()))

compiler/rustc_interface/messages.ftl

@@ -4,6 +4,9 @@ interface_cant_emit_mir =
 interface_emoji_identifier =
     identifiers cannot contain emoji: `{$ident}`
 
+interface_env_var_not_unicode =
+    cannot read environment variable "{$key}" with value "{$var}", since it contains non-unicode data
+
 interface_error_writing_dependencies =
     error writing dependencies to `{$path}`: {$error}
 

compiler/rustc_interface/src/errors.rs

@@ -1,3 +1,4 @@
+use std::ffi::OsString;
 use std::io;
 use std::path::Path;
 
@@ -21,6 +22,13 @@ pub struct EmojiIdentifier {
     pub ident: Symbol,
 }
 
+#[derive(Diagnostic)]
+#[diag(interface_env_var_not_unicode)]
+pub struct EnvVarNotUnicode {
+    pub key: Symbol,
+    pub var: OsString,
+}
+
 #[derive(Diagnostic)]
 #[diag(interface_mixed_bin_crate)]
 pub struct MixedBinCrate;

compiler/rustc_interface/src/passes.rs

@@ -1,4 +1,5 @@
 use std::any::Any;
+use std::env::VarError;
 use std::ffi::OsString;
 use std::io::{self, BufWriter, Write};
 use std::path::{Path, PathBuf};
@@ -336,6 +337,24 @@ fn early_lint_checks(tcx: TyCtxt<'_>, (): ()) {
     )
 }
 
+fn env_var(tcx: TyCtxt<'_>, key: Symbol) -> Option<Symbol> {
+    let var = match std::env::var(key.as_str()) {
+        Ok(var) => Some(Symbol::intern(&var)),
+        Err(VarError::NotPresent) => None,
+        Err(VarError::NotUnicode(var)) => {
+            tcx.dcx().emit_err(errors::EnvVarNotUnicode { key, var });
+            None
+        }
+    };
+    // Also add the variable to Cargo's dependency tracking
+    //
+    // NOTE: This only works for passes run before `write_dep_info`. See that
+    // for extension points for configuring environment variables to be
+    // properly change-tracked.
+    tcx.sess.psess.env_depinfo.borrow_mut().insert((key, var));
+    var
+}
+
 // Returns all the paths that correspond to generated files.
 fn generated_output_paths(
     tcx: TyCtxt<'_>,
@@ -647,6 +666,10 @@ pub fn write_dep_info(tcx: TyCtxt<'_>) {
     // the side-effect of providing a complete set of all
     // accessed files and env vars.
     let _ = tcx.resolver_for_lowering();
+    // Similarly, allow codegen and linking passes to state which environment
+    // variables they depend on, as those passes are run after this pass, but
+    // we'll need the information when emitting dependency info to Cargo.
+    rustc_codegen_ssa::register_environment_variables(tcx);
 
     let sess = tcx.sess;
     let _timer = sess.timer("write_dep_info");
@@ -700,6 +723,7 @@ pub static DEFAULT_QUERY_PROVIDERS: LazyLock<Providers> = LazyLock::new(|| {
         |tcx, _| tcx.arena.alloc_from_iter(tcx.resolutions(()).stripped_cfg_items.steal());
     providers.resolutions = |tcx, ()| tcx.resolver_for_lowering_raw(()).1;
     providers.early_lint_checks = early_lint_checks;
+    providers.env_var = env_var;
     proc_macro_decls::provide(providers);
     rustc_const_eval::provide(providers);
     rustc_middle::hir::provide(providers);

compiler/rustc_middle/src/query/erase.rs

@@ -251,6 +251,7 @@ trivial! {
     Option<rustc_span::def_id::DefId>,
     Option<rustc_span::def_id::LocalDefId>,
     Option<rustc_span::Span>,
+    Option<rustc_span::Symbol>,
     Option<rustc_abi::FieldIdx>,
     Option<rustc_target::spec::PanicStrategy>,
     Option<usize>,

compiler/rustc_middle/src/query/mod.rs

@@ -120,6 +120,23 @@ rustc_queries! {
         desc { "perform lints prior to macro expansion" }
     }
 
+    /// Tracked access to environment variables.
+    ///
+    /// Useful for the implementation of `std::env!`, `proc-macro`s change
+    /// detection and other changes in the compiler's behaviour that is easier
+    /// to control with an environment variable than a flag.
+    ///
+    /// NOTE: This currently does not work with dependency info in the
+    /// analysis, codegen and linking passes, use
+    /// `rustc_codegen_ssa::register_environment_variables` for that.
+    ///
+    /// Will emit an error and return `None` if the variable is not UTF-8.
+    query env_var(key: Symbol) -> Option<Symbol> {
+        // Environment variables are global state
+        eval_always
+        desc { "get the value of an environment variable" }
+    }
+
     query resolutions(_: ()) -> &'tcx ty::ResolverGlobalCtxt {
         no_hash
         desc { "getting the resolver outputs" }