Support multitarget in .cargo/config.toml

For backward compatible reason, `build.target` starts accepting
both array of string and a single string.

Author: weihanglo

src/cargo/core/compiler/compile_kind.rs

@@ -1,4 +1,5 @@
 use crate::core::Target;
+use crate::util::config::BuildTargetConfigValue;
 use crate::util::errors::CargoResult;
 use crate::util::interning::InternedString;
 use crate::util::{Config, StableHasher};
@@ -66,19 +67,34 @@ impl CompileKind {
                 .into_iter()
                 .collect());
         }
-        let kind = match &config.build_config()?.target {
-            Some(val) => {
-                let value = if val.raw_value().ends_with(".json") {
-                    let path = val.clone().resolve_path(config);
-                    path.to_str().expect("must be utf-8 in toml").to_string()
-                } else {
-                    val.raw_value().to_string()
-                };
-                CompileKind::Target(CompileTarget::new(&value)?)
+
+        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 => CompileKind::Host,
         };
-        Ok(vec![kind])
+
+        Ok(kinds)
     }
 
     /// Hash used for fingerprinting.

src/cargo/util/config/mod.rs

@@ -2169,7 +2169,7 @@ pub struct CargoBuildConfig {
     pub dep_info_basedir: Option<ConfigRelativePath>,
     pub target_dir: Option<ConfigRelativePath>,
     pub incremental: Option<bool>,
-    pub target: Option<ConfigRelativePath>,
+    pub target: Option<BuildTargetConfig>,
     pub jobs: Option<u32>,
     pub rustflags: Option<StringList>,
     pub rustdocflags: Option<StringList>,
@@ -2180,6 +2180,56 @@ pub struct CargoBuildConfig {
     pub out_dir: Option<ConfigRelativePath>,
 }
 
+/// Configuration for `build.target`.
+///
+/// Accepts in the following forms:
+///
+/// ```toml
+/// target = "a"
+/// target = ["a"]
+/// target = ["a", "b"]
+/// ```
+#[derive(Debug, Deserialize)]
+#[serde(transparent)]
+pub struct BuildTargetConfig {
+    inner: Value<BuildTargetConfigInner>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(untagged)]
+enum BuildTargetConfigInner {
+    One(String),
+    Many(Vec<String>),
+}
+
+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> {
+            if s.ends_with(".json") {
+                // To absolute path.
+                BuildTargetConfigValue::Path(root.join(s))
+            } else {
+                BuildTargetConfigValue::Simple(s)
+            }
+        }
+        match &self.inner.val {
+            BuildTargetConfigInner::One(s) => vec![map(s, def_root)],
+            BuildTargetConfigInner::Many(v) => v.iter().map(|s| map(s, def_root)).collect(),
+        }
+    }
+}
+
+/// Represents a value of `build.target`.
+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>,