Remove unnecessary enum to reduce code complexity

The relevant is not in the hot path for a cargo build, so it acceptable
to allocation String in order to reduce code coomplexity

Author: weihanglo

src/cargo/core/compiler/compile_kind.rs

@@ -1,5 +1,4 @@
 use crate::core::Target;
-use crate::util::config::BuildTargetConfigValue;
 use crate::util::errors::CargoResult;
 use crate::util::interning::InternedString;
 use crate::util::{Config, StableHasher};
@@ -53,48 +52,31 @@ impl CompileKind {
         config: &Config,
         targets: &[String],
     ) -> CargoResult<Vec<CompileKind>> {
-        if targets.len() > 1 && !config.cli_unstable().multitarget {
-            bail!("specifying multiple `--target` flags requires `-Zmultitarget`")
-        }
-        if !targets.is_empty() {
-            return Ok(targets
+        let dedup = |targets: &[String]| {
+            Ok(targets
                 .iter()
                 .map(|value| Ok(CompileKind::Target(CompileTarget::new(value)?)))
                 // First collect into a set to deduplicate any `--target` passed
                 // more than once...
                 .collect::<CargoResult<BTreeSet<_>>>()?
                 // ... then generate a flat list for everything else to use.
                 .into_iter()
-                .collect());
+                .collect())
+        };
+
+        if !targets.is_empty() {
+            if targets.len() > 1 && !config.cli_unstable().multitarget {
+                bail!("specifying multiple `--target` flags requires `-Zmultitarget`")
+            }
+            return dedup(targets);
         }
 
         let kinds = match &config.build_config()?.target {
-            None => vec![CompileKind::Host],
-            Some(build_target_config) => {
-                let values = build_target_config.values(config);
-                if values.len() > 1 && !config.cli_unstable().multitarget {
-                    bail!("specifying multiple `--target` flags requires `-Zmultitarget`")
-                }
-                values
-                    .into_iter()
-                    .map(|k| {
-                        use BuildTargetConfigValue::*;
-                        let value = match &k {
-                            Path(p) => p.to_str().expect("must be utf-8 in toml"),
-                            Simple(s) => s,
-                        };
-                        CompileTarget::new(value).map(CompileKind::Target)
-                    })
-                    // First collect into a set to deduplicate any `--target` passed
-                    // more than once...
-                    .collect::<CargoResult<BTreeSet<_>>>()?
-                    // ... then generate a flat list for everything else to use.
-                    .into_iter()
-                    .collect()
-            }
+            None => Ok(vec![CompileKind::Host]),
+            Some(build_target_config) => dedup(&build_target_config.values(config)?),
         };
 
-        Ok(kinds)
+        kinds
     }
 
     /// Hash used for fingerprinting.

src/cargo/util/config/mod.rs

@@ -2203,34 +2203,38 @@ enum BuildTargetConfigInner {
 }
 
 impl BuildTargetConfig {
-    /// Gets values of `build.target` as a list of [`BuildTargetConfigValue`].
-    pub fn values(&self, config: &Config) -> Vec<BuildTargetConfigValue<'_>> {
-        let def_root = self.inner.definition.root(config);
-        fn map<'a>(s: &'a str, root: &Path) -> BuildTargetConfigValue<'a> {
+    /// Gets values of `build.target` as a list of strings.
+    pub fn values(&self, config: &Config) -> CargoResult<Vec<String>> {
+        let map = |s: &String| {
             if s.ends_with(".json") {
-                // To absolute path.
-                BuildTargetConfigValue::Path(root.join(s))
+                // Path to a target specification file (in JSON).
+                // <https://doc.rust-lang.org/rustc/targets/custom.html>
+                self.inner
+                    .definition
+                    .root(config)
+                    .join(s)
+                    .to_str()
+                    .expect("must be utf-8 in toml")
+                    .to_string()
             } else {
-                BuildTargetConfigValue::Simple(s)
+                // A string. Probably a target triple.
+                s.to_string()
             }
-        }
-        match &self.inner.val {
-            BuildTargetConfigInner::One(s) => vec![map(s, def_root)],
-            BuildTargetConfigInner::Many(v) => v.iter().map(|s| map(s, def_root)).collect(),
-        }
+        };
+        let values = match &self.inner.val {
+            BuildTargetConfigInner::One(s) => vec![map(s)],
+            BuildTargetConfigInner::Many(v) => {
+                if v.len() > 1 && !config.cli_unstable().multitarget {
+                    bail!("specifying multiple `target` in `build.target` config value requires `-Zmultitarget`")
+                } else {
+                    v.iter().map(map).collect()
+                }
+            }
+        };
+        Ok(values)
     }
 }
 
-/// Represents a value of `build.target`.
-#[derive(Debug)]
-pub enum BuildTargetConfigValue<'a> {
-    /// Path to a target specification file (in JSON).
-    /// <https://doc.rust-lang.org/rustc/targets/custom.html>
-    Path(PathBuf),
-    /// A string. Probably a target triple.
-    Simple(&'a str),
-}
-
 #[derive(Deserialize, Default)]
 struct TermConfig {
     verbose: Option<bool>,