feat(trim-paths): parsing in mainfest and config

Author: weihanglo

src/cargo/core/profiles.rs

@@ -26,6 +26,7 @@ use crate::core::dependency::Artifact;
 use crate::core::resolver::features::FeaturesFor;
 use crate::core::{PackageId, PackageIdSpec, Resolve, Shell, Target, Workspace};
 use crate::util::interning::InternedString;
+use crate::util::toml::TomlTrimPaths;
 use crate::util::toml::{
     ProfilePackageSpec, StringOrBool, TomlDebugInfo, TomlProfile, TomlProfiles,
 };
@@ -555,6 +556,9 @@ fn merge_profile(profile: &mut Profile, toml: &TomlProfile) {
     if let Some(flags) = &toml.rustflags {
         profile.rustflags = flags.clone();
     }
+    if let Some(trim_paths) = &toml.trim_paths {
+        profile.trim_paths = Some(trim_paths.clone());
+    }
     profile.strip = match toml.strip {
         Some(StringOrBool::Bool(true)) => Strip::Named(InternedString::new("symbols")),
         None | Some(StringOrBool::Bool(false)) => Strip::None,
@@ -598,6 +602,9 @@ pub struct Profile {
     #[serde(skip_serializing_if = "Vec::is_empty")] // remove when `rustflags` is stablized
     // Note that `rustflags` is used for the cargo-feature `profile_rustflags`
     pub rustflags: Vec<InternedString>,
+    // remove when `-Ztrim-paths` is stablized
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub trim_paths: Option<TomlTrimPaths>,
 }
 
 impl Default for Profile {
@@ -618,6 +625,7 @@ impl Default for Profile {
             panic: PanicStrategy::Unwind,
             strip: Strip::None,
             rustflags: vec![],
+            trim_paths: None,
         }
     }
 }
@@ -646,6 +654,7 @@ compact_debug! {
                 panic
                 strip
                 rustflags
+                trim_paths
             )]
         }
     }
@@ -712,6 +721,7 @@ impl Profile {
             self.rpath,
             (self.incremental, self.panic, self.strip),
             &self.rustflags,
+            &self.trim_paths,
         )
     }
 }

src/cargo/util/toml/mod.rs

@@ -2671,6 +2671,8 @@ pub struct TomlProfile {
     // requires all non-tables to be listed first.
     pub package: Option<BTreeMap<ProfilePackageSpec, TomlProfile>>,
     pub build_override: Option<Box<TomlProfile>>,
+    /// Unstable feature `-Ztrim-paths`.
+    pub trim_paths: Option<TomlTrimPaths>,
 }
 
 impl TomlProfile {
@@ -2871,6 +2873,15 @@ impl TomlProfile {
                 _ => {}
             }
         }
+        if self.trim_paths.is_some() {
+            match (
+                features.require(Feature::trim_paths()),
+                cli_unstable.trim_paths,
+            ) {
+                (Err(e), false) => return Err(e),
+                _ => {}
+            }
+        }
         Ok(())
     }
 
@@ -3146,6 +3157,120 @@ impl<'de> de::Deserialize<'de> for TomlDebugInfo {
     }
 }
 
+#[derive(Clone, Debug, PartialEq, Eq, Ord, PartialOrd, Hash, Serialize)]
+#[serde(untagged)]
+pub enum TomlTrimPaths {
+    One(TomlTrimPathsValue),
+    Many(Vec<TomlTrimPathsValue>),
+}
+
+impl<'de> de::Deserialize<'de> for TomlTrimPaths {
+    fn deserialize<D>(d: D) -> Result<TomlTrimPaths, D::Error>
+    where
+        D: de::Deserializer<'de>,
+    {
+        let expecting = r#"a boolean, "none", "macro", "diagnostics", "object", "all", or a list of these options"#;
+        UntaggedEnumVisitor::new()
+            .expecting(expecting)
+            .bool(|value| {
+                Ok(if value {
+                    TomlTrimPaths::all()
+                } else {
+                    TomlTrimPaths::none()
+                })
+            })
+            .string(|value| {
+                TomlTrimPathsValue::deserialize(value.into_deserializer()).map(TomlTrimPaths::One)
+            })
+            .seq(|seq| {
+                let seq: Vec<String> = seq.deserialize()?;
+                let seq = seq
+                    .into_iter()
+                    .map(|s| TomlTrimPathsValue::deserialize(s.into_deserializer()))
+                    .collect::<Result<_, _>>()?;
+                Ok(TomlTrimPaths::Many(seq))
+            })
+            .deserialize(d)
+    }
+}
+
+impl TomlTrimPaths {
+    pub fn none() -> TomlTrimPaths {
+        TomlTrimPaths::One(TomlTrimPathsValue::None)
+    }
+
+    pub fn all() -> TomlTrimPaths {
+        TomlTrimPaths::One(TomlTrimPathsValue::All)
+    }
+
+    pub fn diagnostics() -> TomlTrimPaths {
+        TomlTrimPaths::One(TomlTrimPathsValue::Diagnostics)
+    }
+
+    pub fn r#macro() -> TomlTrimPaths {
+        TomlTrimPaths::One(TomlTrimPathsValue::Macro)
+    }
+
+    pub fn object() -> TomlTrimPaths {
+        TomlTrimPaths::One(TomlTrimPathsValue::Object)
+    }
+
+    pub fn is_none(&self) -> bool {
+        match self {
+            TomlTrimPaths::One(TomlTrimPathsValue::None) => true,
+            TomlTrimPaths::Many(list) if list.is_empty() => true,
+            TomlTrimPaths::Many(list) => list.iter().any(|v| matches!(v, TomlTrimPathsValue::None)),
+            _ => false,
+        }
+    }
+}
+
+impl fmt::Display for TomlTrimPaths {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            TomlTrimPaths::One(value) => write!(f, "{value}"),
+            TomlTrimPaths::Many(values) => {
+                let mut iter = values.iter();
+                if let Some(value) = iter.next() {
+                    write!(f, "{value}")?;
+                }
+                for value in iter {
+                    write!(f, ",{value}")?;
+                }
+                Ok(())
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum TomlTrimPathsValue {
+    None,
+    Diagnostics,
+    Macro,
+    Object,
+    All,
+}
+
+impl TomlTrimPathsValue {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            TomlTrimPathsValue::None => "none",
+            TomlTrimPathsValue::Diagnostics => "diagnostics",
+            TomlTrimPathsValue::Macro => "macro",
+            TomlTrimPathsValue::Object => "object",
+            TomlTrimPathsValue::All => "all",
+        }
+    }
+}
+
+impl fmt::Display for TomlTrimPathsValue {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
 type TomlLibTarget = TomlTarget;
 type TomlBinTarget = TomlTarget;
 type TomlExampleTarget = TomlTarget;

tests/testsuite/config.rs

@@ -1541,6 +1541,7 @@ fn all_profile_options() {
         package: None,
         build_override: None,
         rustflags: None,
+        trim_paths: None,
     };
     let mut overrides = BTreeMap::new();
     let key = cargo_toml::ProfilePackageSpec::Spec(PackageIdSpec::parse("foo").unwrap());