refactored to macro based metadata env vars tracking

ranger-ross · ranger-ross · commit d999267de2de · 2024-12-24T13:43:08.000+09:00
diff --git a/src/cargo/core/compiler/compilation.rs b/src/cargo/core/compiler/compilation.rs
@@ -1,6 +1,5 @@
 //! Type definitions for the result of a compilation.
 
-use std::borrow::Cow;
 use std::collections::{BTreeSet, HashMap};
 use std::ffi::{OsStr, OsString};
 use std::path::PathBuf;
@@ -359,11 +358,17 @@ impl<'gctx> Compilation<'gctx> {
         // crate properties which might require rebuild upon change
         // consider adding the corresponding properties to the hash
         // in BuildContext::target_metadata()
-        for (key, value) in pkg.emitted_env_vars() {
-            match value {
-                Cow::Borrowed(value) => cmd.env(key, value),
-                Cow::Owned(ref value) => cmd.env(key, value.as_str()),
-            };
+        cmd.env("CARGO_MANIFEST_DIR", pkg.root())
+            .env("CARGO_MANIFEST_PATH", pkg.manifest_path())
+            .env("CARGO_PKG_VERSION_MAJOR", &pkg.version().major.to_string())
+            .env("CARGO_PKG_VERSION_MINOR", &pkg.version().minor.to_string())
+            .env("CARGO_PKG_VERSION_PATCH", &pkg.version().patch.to_string())
+            .env("CARGO_PKG_VERSION_PRE", pkg.version().pre.as_str())
+            .env("CARGO_PKG_VERSION", &pkg.version().to_string())
+            .env("CARGO_PKG_NAME", &*pkg.name());
+
+        for (key, value) in pkg.manifest().metadata().env_vars() {
+            cmd.env(key, value.as_ref());
         }
 
         cmd.cwd(pkg.root());
diff --git a/src/cargo/core/compiler/fingerprint/dep_info.rs b/src/cargo/core/compiler/fingerprint/dep_info.rs
@@ -19,7 +19,7 @@ use cargo_util::paths;
 use cargo_util::ProcessBuilder;
 use cargo_util::Sha256;
 
-use crate::core::package::EmittablePackageMetadata;
+use crate::core::manifest::ManifestMetadata;
 use crate::CargoResult;
 use crate::CARGO_ENV;
 
@@ -335,7 +335,7 @@ pub fn translate_dep_info(
     //
     // For cargo#13280, We trace env vars that are defined in the `[env]` config table.
     on_disk_info.env.retain(|(key, _)| {
-        EmittablePackageMetadata::is_emittable_env_var(key)
+        ManifestMetadata::should_track(key)
             || env_config.contains_key(key)
             || !rustc_cmd.get_envs().contains_key(key)
             || key == CARGO_ENV
diff --git a/src/cargo/core/compiler/fingerprint/mod.rs b/src/cargo/core/compiler/fingerprint/mod.rs
@@ -189,7 +189,7 @@
 //! Cargo then later uses this to trigger a recompile if a referenced env var
 //! changes (even if the source didn't change).
 //! This also includes env vars generated from Cargo metadata like `CARGO_PKG_DESCRIPTION`.
-//! (See [`EmittablePackageMetadata`])
+//! (See [`crate::core::manifest::ManifestMetadata`]
 //!
 //! #### dep-info files for build system integration.
 //!
@@ -372,15 +372,13 @@
 mod dep_info;
 mod dirty_reason;
 
-use std::borrow::Cow;
 use std::collections::hash_map::{Entry, HashMap};
 use std::env;
 use std::fs;
 use std::fs::File;
 use std::hash::{self, Hash, Hasher};
 use std::io::{self};
 use std::path::{Path, PathBuf};
-use std::str::FromStr;
 use std::sync::{Arc, Mutex};
 use std::time::SystemTime;
 
@@ -394,7 +392,6 @@ use serde::{Deserialize, Serialize};
 use tracing::{debug, info};
 
 use crate::core::compiler::unit_graph::UnitDep;
-use crate::core::package::EmittablePackageMetadata;
 use crate::core::Package;
 use crate::util;
 use crate::util::errors::CargoResult;
@@ -850,14 +847,8 @@ impl LocalFingerprint {
                     return Ok(Some(StaleItem::MissingFile(dep_info)));
                 };
                 for (key, previous) in info.env.iter() {
-                    if let Ok(t) = EmittablePackageMetadata::from_str(key.as_str()) {
-                        let value = pkg.emitted_env_var(&t);
-                        let value = match value {
-                            Cow::Borrowed(v) => v,
-                            Cow::Owned(ref v) => v.as_str(),
-                        };
-
-                        if Some(value) == previous.as_deref() {
+                    if let Some(value) = pkg.manifest().metadata().env_var(key.as_str()) {
+                        if Some(value.as_ref()) == previous.as_deref() {
                             continue;
                         }
                     }
diff --git a/src/cargo/core/manifest.rs b/src/cargo/core/manifest.rs
@@ -1,3 +1,4 @@
+use std::borrow::Cow;
 use std::collections::{BTreeMap, HashMap};
 use std::fmt;
 use std::hash::{Hash, Hasher};
@@ -146,6 +147,86 @@ pub struct ManifestMetadata {
     pub rust_version: Option<RustVersion>,
 }
 
+macro_rules! get_metadata_env {
+    ($meta:ident, $field:ident) => {
+        $meta.$field.as_deref().unwrap_or_default().into()
+    };
+    ($meta:ident, $field:ident, $to_var:expr) => {
+        $to_var($meta).into()
+    };
+}
+
+macro_rules! metadata_envs {
+    (
+        $(
+            ($field:ident, $key:literal$(, $to_var:expr)?),
+        )*
+    ) => {
+        struct MetadataEnvs;
+        impl MetadataEnvs {
+            $(
+                fn $field(meta: &ManifestMetadata) -> Cow<'_, str> {
+                    get_metadata_env!(meta, $field$(, $to_var)?)
+                }
+            )*
+
+            pub fn should_track(key: &str) -> bool {
+                let keys = [$($key),*];
+                key.strip_prefix("CARGO_PKG_")
+                    .map(|key| keys.iter().any(|k| *k == key))
+                    .unwrap_or_default()
+            }
+
+            pub fn var<'a>(meta: &'a ManifestMetadata, key: &str) -> Option<Cow<'a, str>> {
+                key.strip_prefix("CARGO_PKG_").and_then(|key| match key {
+                    $($key => Some(Self::$field(meta)),)*
+                    _ => None,
+                })
+            }
+
+            pub fn vars(meta: &ManifestMetadata) -> impl Iterator<Item = (&'static str, Cow<'_, str>)> {
+                [
+                    $(
+                        (
+                            concat!("CARGO_PKG_", $key),
+                            Self::$field(meta),
+                        ),
+                    )*
+                ].into_iter()
+            }
+        }
+    }
+}
+
+// Metadata enviromental variables that are emitted to rustc. Usable by `env!()`
+// If these change we need to trigger a rebuild.
+// NOTE: The env var name will be prefixed with `CARGO_PKG_`
+metadata_envs! {
+    (description, "DESCRIPTION"),
+    (homepage, "HOMEPAGE"),
+    (repository, "REPOSITORY"),
+    (license, "LICENSE"),
+    (license_file, "LICENSE_FILE"),
+    (authors, "AUTHORS", |m: &ManifestMetadata| m.authors.join(":")),
+    (rust_version, "RUST_VERSION", |m: &ManifestMetadata| m.rust_version.as_ref().map(ToString::to_string).unwrap_or_default()),
+    (readme, "README"),
+}
+
+impl ManifestMetadata {
+    /// Whether the given env var should be tracked by Cargo's dep-info.
+    pub fn should_track(env_key: &str) -> bool {
+        MetadataEnvs::should_track(env_key)
+    }
+
+    pub fn env_var<'a>(&'a self, env_key: &str) -> Option<Cow<'a, str>> {
+        MetadataEnvs::var(self, env_key)
+    }
+
+    pub fn env_vars(&self) -> impl Iterator<Item = (&'static str, Cow<'_, str>)> {
+        MetadataEnvs::vars(self)
+    }
+}
+
 #[derive(Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub enum TargetKind {
     Lib(Vec<CrateType>),
diff --git a/src/cargo/core/package.rs b/src/cargo/core/package.rs
@@ -1,4 +1,3 @@
-use std::borrow::Cow;
 use std::cell::{Cell, Ref, RefCell, RefMut};
 use std::cmp::Ordering;
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
@@ -7,7 +6,6 @@ use std::hash;
 use std::mem;
 use std::path::{Path, PathBuf};
 use std::rc::Rc;
-use std::str::FromStr;
 use std::time::{Duration, Instant};
 
 use anyhow::Context as _;
@@ -254,122 +252,6 @@ impl Package {
     }
 }
 
-/// "Emittable" here meaning emitted to rustc as enviromental variables. Usable by `env!()`
-/// If these change we need to trigger a rebuild
-/// NOTE: If you add a new variant also add a mapping entry in [`EMITTED_METADATA_MAPPINGS`]
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum EmittablePackageMetadata {
-    ManifestDir,
-    ManifestPath,
-    Name,
-    Version,
-    VersionMajor,
-    VersionMinor,
-    VersionPatch,
-    VersionPre,
-    Description,
-    Homepage,
-    Repository,
-    License,
-    LicenseFile,
-    Authors,
-    RustVersion,
-    Readme,
-}
-
-use crate::core::package::EmittablePackageMetadata::*;
-const EMITTED_METADATA_MAPPINGS: [(EmittablePackageMetadata, &'static str); 16] = [
-    (ManifestDir, "CARGO_MANIFEST_DIR"),
-    (ManifestPath, "CARGO_MANIFEST_PATH"),
-    (Name, "CARGO_PKG_NAME"),
-    (Version, "CARGO_PKG_VERSION"),
-    (VersionMajor, "CARGO_PKG_VERSION_MAJOR"),
-    (VersionMinor, "CARGO_PKG_VERSION_MINOR"),
-    (VersionPatch, "CARGO_PKG_VERSION_PATCH"),
-    (VersionPre, "CARGO_PKG_VERSION_PRE"),
-    (Description, "CARGO_PKG_DESCRIPTION"),
-    (Homepage, "CARGO_PKG_HOMEPAGE"),
-    (Repository, "CARGO_PKG_REPOSITORY"),
-    (License, "CARGO_PKG_LICENSE"),
-    (LicenseFile, "CARGO_PKG_LICENSE_FILE"),
-    (Authors, "CARGO_PKG_AUTHORS"),
-    (RustVersion, "CARGO_PKG_RUST_VERSION"),
-    (Readme, "CARGO_PKG_README"),
-];
-
-impl FromStr for EmittablePackageMetadata {
-    type Err = String;
-
-    fn from_str(value: &str) -> Result<Self, Self::Err> {
-        if let Some(v) = EMITTED_METADATA_MAPPINGS.iter().find(|v| v.1 == value) {
-            return Ok(v.0);
-        }
-
-        return Err(format!("Invalid emittable manifest metadata key {value}"));
-    }
-}
-
-impl From<EmittablePackageMetadata> for &'static str {
-    fn from(value: EmittablePackageMetadata) -> Self {
-        if let Some(v) = EMITTED_METADATA_MAPPINGS.iter().find(|v| v.0 == value) {
-            return v.1;
-        }
-
-        unreachable!("unknown package metadata");
-    }
-}
-
-impl EmittablePackageMetadata {
-    pub fn is_emittable_env_var(key: &str) -> bool {
-        EmittablePackageMetadata::from_str(key).is_ok()
-    }
-}
-
-impl Package {
-    // k/v pairs of the metadata environmental variables emitted to rustc.
-    pub fn emitted_env_vars(&self) -> Vec<(&'static str, Cow<'_, str>)> {
-        let mut vars = Vec::with_capacity(EMITTED_METADATA_MAPPINGS.len());
-
-        for (key, name) in EMITTED_METADATA_MAPPINGS {
-            let value = self.emitted_env_var(&key);
-            vars.push((name, value));
-        }
-
-        return vars;
-    }
-
-    pub fn emitted_env_var<'a>(&'a self, key: &EmittablePackageMetadata) -> Cow<'a, str> {
-        let metadata = self.manifest().metadata();
-        let value = match key {
-            ManifestDir => self.root().as_os_str().to_str().unwrap_or_default(),
-            ManifestPath => self
-                .manifest_path()
-                .as_os_str()
-                .to_str()
-                .unwrap_or_default(),
-            Name => self.name().as_str(),
-            Version => return Cow::Owned(self.version().to_string()),
-            VersionMajor => return Cow::Owned(self.version().major.to_string()),
-            VersionMinor => return Cow::Owned(self.version().minor.to_string()),
-            VersionPatch => return Cow::Owned(self.version().patch.to_string()),
-            VersionPre => return Cow::Owned(self.version().pre.to_string()),
-            Description => metadata.description.as_deref().unwrap_or_default(),
-            Homepage => metadata.homepage.as_deref().unwrap_or_default(),
-            Repository => metadata.repository.as_deref().unwrap_or_default(),
-            License => metadata.license.as_deref().unwrap_or_default(),
-            LicenseFile => metadata.license_file.as_deref().unwrap_or_default(),
-            Authors => return Cow::Owned(metadata.authors.join(":")),
-            RustVersion => {
-                let rust_version = metadata.rust_version.as_ref().map(ToString::to_string);
-                return Cow::Owned(rust_version.unwrap_or_default());
-            }
-            Readme => metadata.readme.as_deref().unwrap_or_default(),
-        };
-
-        return Cow::Borrowed(value);
-    }
-}
-
 impl fmt::Display for Package {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.summary().package_id())
