feat: Support passing multiple targets to cargo (for Rust 1.64.0+)

Author: poliorcetics

crates/flycheck/src/lib.rs

@@ -25,7 +25,7 @@ pub use cargo_metadata::diagnostic::{
 pub enum FlycheckConfig {
     CargoCommand {
         command: String,
-        target_triple: Option<String>,
+        target_triples: Vec<String>,
         all_targets: bool,
         no_default_features: bool,
         all_features: bool,
@@ -253,7 +253,7 @@ impl FlycheckActor {
         let mut cmd = match &self.config {
             FlycheckConfig::CargoCommand {
                 command,
-                target_triple,
+                target_triples,
                 no_default_features,
                 all_targets,
                 all_features,
@@ -267,7 +267,7 @@ impl FlycheckActor {
                 cmd.args(&["--workspace", "--message-format=json", "--manifest-path"])
                     .arg(self.workspace_root.join("Cargo.toml").as_os_str());
 
-                if let Some(target) = target_triple {
+                for target in target_triples {
                     cmd.args(&["--target", target.as_str()]);
                 }
                 if *all_targets {

crates/project-model/src/build_scripts.rs

@@ -52,12 +52,12 @@ impl WorkspaceBuildScripts {
         cmd.args(&["check", "--quiet", "--workspace", "--message-format=json"]);
 
         // --all-targets includes tests, benches and examples in addition to the
-        // default lib and bins. This is an independent concept from the --targets
+        // default lib and bins. This is an independent concept from the --target
         // flag below.
         cmd.arg("--all-targets");
 
-        if let Some(target) = &config.target {
-            cmd.args(&["--target", target]);
+        for target in &config.targets {
+            cmd.args(&["--target", target.as_str()]);
         }
 
         match &config.features {

crates/project-model/src/cargo_workspace.rs

@@ -92,8 +92,8 @@ impl Default for CargoFeatures {
 pub struct CargoConfig {
     /// List of features to activate.
     pub features: CargoFeatures,
-    /// rustc target
-    pub target: Option<String>,
+    /// rustc targets
+    pub targets: Vec<String>,
     /// Don't load sysroot crates (`std`, `core` & friends). Might be useful
     /// when debugging isolated issues.
     pub no_sysroot: bool,
@@ -269,11 +269,7 @@ impl CargoWorkspace {
         config: &CargoConfig,
         progress: &dyn Fn(String),
     ) -> Result<cargo_metadata::Metadata> {
-        let target = config
-            .target
-            .clone()
-            .or_else(|| cargo_config_build_target(cargo_toml, &config.extra_env))
-            .or_else(|| rustc_discover_host_triple(cargo_toml, &config.extra_env));
+        let targets = find_list_of_build_targets(config, cargo_toml);
 
         let mut meta = MetadataCommand::new();
         meta.cargo_path(toolchain::cargo());
@@ -295,8 +291,12 @@ impl CargoWorkspace {
         }
         meta.current_dir(current_dir.as_os_str());
 
-        if let Some(target) = target {
-            meta.other_options(vec![String::from("--filter-platform"), target]);
+        if !targets.is_empty() {
+            let other_options: Vec<_> = targets
+                .into_iter()
+                .flat_map(|target| ["--filter-platform".to_string(), target])
+                .collect();
+            meta.other_options(other_options);
         }
 
         // FIXME: Fetching metadata is a slow process, as it might require
@@ -466,10 +466,23 @@ impl CargoWorkspace {
     }
 }
 
+fn find_list_of_build_targets(config: &CargoConfig, cargo_toml: &ManifestPath) -> Vec<String> {
+    if !config.targets.is_empty() {
+        return config.targets.clone();
+    }
+
+    let build_targets = cargo_config_build_target(cargo_toml, &config.extra_env);
+    if !build_targets.is_empty() {
+        return build_targets;
+    }
+
+    rustc_discover_host_triple(cargo_toml, &config.extra_env)
+}
+
 fn rustc_discover_host_triple(
     cargo_toml: &ManifestPath,
     extra_env: &FxHashMap<String, String>,
-) -> Option<String> {
+) -> Vec<String> {
     let mut rustc = Command::new(toolchain::rustc());
     rustc.envs(extra_env);
     rustc.current_dir(cargo_toml.parent()).arg("-vV");
@@ -479,37 +492,46 @@ fn rustc_discover_host_triple(
             let field = "host: ";
             let target = stdout.lines().find_map(|l| l.strip_prefix(field));
             if let Some(target) = target {
-                Some(target.to_string())
+                [target.to_string()].to_vec()
             } else {
                 // If we fail to resolve the host platform, it's not the end of the world.
                 tracing::info!("rustc -vV did not report host platform, got:\n{}", stdout);
-                None
+                Vec::new()
             }
         }
         Err(e) => {
             tracing::warn!("Failed to discover host platform: {}", e);
-            None
+            Vec::new()
         }
     }
 }
 
 fn cargo_config_build_target(
     cargo_toml: &ManifestPath,
     extra_env: &FxHashMap<String, String>,
-) -> Option<String> {
+) -> Vec<String> {
     let mut cargo_config = Command::new(toolchain::cargo());
     cargo_config.envs(extra_env);
     cargo_config
         .current_dir(cargo_toml.parent())
         .args(&["-Z", "unstable-options", "config", "get", "build.target"])
         .env("RUSTC_BOOTSTRAP", "1");
     // if successful we receive `build.target = "target-triple"`
+    // or `build.target = ["<target 1>", ..]`
     tracing::debug!("Discovering cargo config target by {:?}", cargo_config);
-    match utf8_stdout(cargo_config) {
-        Ok(stdout) => stdout
-            .strip_prefix("build.target = \"")
-            .and_then(|stdout| stdout.strip_suffix('"'))
-            .map(ToOwned::to_owned),
-        Err(_) => None,
+    utf8_stdout(cargo_config).map(parse_output_cargo_config_build_target).unwrap_or_default()
+}
+
+fn parse_output_cargo_config_build_target(stdout: String) -> Vec<String> {
+    let trimmed = stdout.trim_start_matches("build.target = ").trim_matches('"');
+
+    if !trimmed.starts_with('[') {
+        return [trimmed.to_string()].to_vec();
+    }
+
+    let res = serde_json::from_str(trimmed);
+    if let Err(e) = &res {
+        tracing::warn!("Failed to parse `build.target` as an array of target: {}`", e);
     }
+    res.unwrap_or_default()
 }

crates/project-model/src/project_json.rs

@@ -35,6 +35,7 @@ pub struct Crate {
     pub(crate) version: Option<String>,
     pub(crate) deps: Vec<Dependency>,
     pub(crate) cfg: Vec<CfgFlag>,
+    // XXX: support multiple targets ? (Rust 1.64.0+)
     pub(crate) target: Option<String>,
     pub(crate) env: FxHashMap<String, String>,
     pub(crate) proc_macro_dylib_path: Option<AbsPathBuf>,

crates/project-model/src/rustc_cfg.rs

@@ -9,7 +9,7 @@ use crate::{cfg_flag::CfgFlag, utf8_stdout, ManifestPath};
 
 pub(crate) fn get(
     cargo_toml: Option<&ManifestPath>,
-    target: Option<&str>,
+    targets: &[String],
     extra_env: &FxHashMap<String, String>,
 ) -> Vec<CfgFlag> {
     let _p = profile::span("rustc_cfg::get");
@@ -23,7 +23,7 @@ pub(crate) fn get(
         }
     }
 
-    match get_rust_cfgs(cargo_toml, target, extra_env) {
+    match get_rust_cfgs(cargo_toml, targets, extra_env) {
         Ok(rustc_cfgs) => {
             tracing::debug!(
                 "rustc cfgs found: {:?}",
@@ -42,7 +42,7 @@ pub(crate) fn get(
 
 fn get_rust_cfgs(
     cargo_toml: Option<&ManifestPath>,
-    target: Option<&str>,
+    targets: &[String],
     extra_env: &FxHashMap<String, String>,
 ) -> Result<String> {
     if let Some(cargo_toml) = cargo_toml {
@@ -52,7 +52,7 @@ fn get_rust_cfgs(
             .current_dir(cargo_toml.parent())
             .args(&["-Z", "unstable-options", "rustc", "--print", "cfg"])
             .env("RUSTC_BOOTSTRAP", "1");
-        if let Some(target) = target {
+        for target in targets {
             cargo_config.args(&["--target", target]);
         }
         match utf8_stdout(cargo_config) {
@@ -64,7 +64,7 @@ fn get_rust_cfgs(
     let mut cmd = Command::new(toolchain::rustc());
     cmd.envs(extra_env);
     cmd.args(&["--print", "cfg", "-O"]);
-    if let Some(target) = target {
+    for target in targets {
         cmd.args(&["--target", target]);
     }
     utf8_stdout(cmd)

crates/project-model/src/workspace.rs

@@ -156,11 +156,7 @@ impl ProjectWorkspace {
                 })?;
                 let project_location = project_json.parent().to_path_buf();
                 let project_json = ProjectJson::new(&project_location, data);
-                ProjectWorkspace::load_inline(
-                    project_json,
-                    config.target.as_deref(),
-                    &config.extra_env,
-                )?
+                ProjectWorkspace::load_inline(project_json, &config.targets, &config.extra_env)?
             }
             ProjectManifest::CargoToml(cargo_toml) => {
                 let cargo_version = utf8_stdout({
@@ -226,7 +222,7 @@ impl ProjectWorkspace {
                 };
 
                 let rustc_cfg =
-                    rustc_cfg::get(Some(&cargo_toml), config.target.as_deref(), &config.extra_env);
+                    rustc_cfg::get(Some(&cargo_toml), &config.targets, &config.extra_env);
 
                 let cfg_overrides = config.cfg_overrides();
                 ProjectWorkspace::Cargo {
@@ -246,7 +242,7 @@ impl ProjectWorkspace {
 
     pub fn load_inline(
         project_json: ProjectJson,
-        target: Option<&str>,
+        targets: &[String],
         extra_env: &FxHashMap<String, String>,
     ) -> Result<ProjectWorkspace> {
         let sysroot = match (project_json.sysroot.clone(), project_json.sysroot_src.clone()) {
@@ -269,7 +265,7 @@ impl ProjectWorkspace {
             (None, None) => None,
         };
 
-        let rustc_cfg = rustc_cfg::get(None, target, extra_env);
+        let rustc_cfg = rustc_cfg::get(None, targets, extra_env);
         Ok(ProjectWorkspace::Json { project: project_json, sysroot, rustc_cfg })
     }
 
@@ -281,7 +277,7 @@ impl ProjectWorkspace {
                 .ok_or_else(|| format_err!("No detached files to load"))?,
             &Default::default(),
         )?;
-        let rustc_cfg = rustc_cfg::get(None, None, &Default::default());
+        let rustc_cfg = rustc_cfg::get(None, &[], &Default::default());
         Ok(ProjectWorkspace::DetachedFiles { files: detached_files, sysroot, rustc_cfg })
     }
 
@@ -499,7 +495,7 @@ fn project_json_to_crate_graph(
             let target_cfgs = match krate.target.as_deref() {
                 Some(target) => cfg_cache
                     .entry(target)
-                    .or_insert_with(|| rustc_cfg::get(None, Some(target), extra_env)),
+                    .or_insert_with(|| rustc_cfg::get(None, &[target.into()], extra_env)),
                 None => &rustc_cfg,
             };
 

crates/rust-analyzer/src/config.rs

@@ -96,8 +96,10 @@ config_data! {
         cargo_noDefaultFeatures: bool    = "false",
         /// Internal config for debugging, disables loading of sysroot crates.
         cargo_noSysroot: bool            = "false",
-        /// Compilation target override (target triple).
-        cargo_target: Option<String>     = "null",
+        /// Compilation targets override (target triples).
+        /// Setting this with multiple elements is like passing multiple
+        /// `--target` flags to `cargo`, only available on Rust 1.64.0+.
+        cargo_target: Vec<String>        = "[]",
         /// Unsets `#[cfg(test)]` for the specified crates.
         cargo_unsetTest: Vec<String>     = "[\"core\"]",
 
@@ -139,9 +141,9 @@ config_data! {
         /// ```
         /// .
         checkOnSave_overrideCommand: Option<Vec<String>> = "null",
-        /// Check for a specific target. Defaults to
-        /// `#rust-analyzer.cargo.target#`.
-        checkOnSave_target: Option<String>               = "null",
+        /// Check for specific targets. Defaults to
+        /// `#rust-analyzer.cargo.targets#`.
+        checkOnSave_target: Vec<String>                  = "[]",
 
         /// Toggles the additional completions that automatically add imports when completed.
         /// Note that your client must specify the `additionalTextEdits` LSP client capability to truly have this feature enabled.
@@ -1037,7 +1039,7 @@ impl Config {
                     no_default_features: self.data.cargo_noDefaultFeatures,
                 },
             },
-            target: self.data.cargo_target.clone(),
+            targets: self.data.cargo_target.clone(),
             no_sysroot: self.data.cargo_noSysroot,
             rustc_source,
             unset_test_crates: UnsetTestCrates::Only(self.data.cargo_unsetTest.clone()),
@@ -1077,11 +1079,15 @@ impl Config {
             }
             Some(_) | None => FlycheckConfig::CargoCommand {
                 command: self.data.checkOnSave_command.clone(),
-                target_triple: self
+                target_triples: self
                     .data
                     .checkOnSave_target
-                    .clone()
-                    .or_else(|| self.data.cargo_target.clone()),
+                    .is_empty()
+                    // If empty, fallback to `cargo_target`
+                    .then_some(&self.data.cargo_target)
+                    // Else use specified data
+                    .unwrap_or(&self.data.checkOnSave_target)
+                    .clone(),
                 all_targets: self.data.checkOnSave_allTargets,
                 no_default_features: self
                     .data

crates/rust-analyzer/src/reload.rs

@@ -142,7 +142,7 @@ impl GlobalState {
                         LinkedProject::InlineJsonProject(it) => {
                             project_model::ProjectWorkspace::load_inline(
                                 it.clone(),
-                                cargo_config.target.as_deref(),
+                                &cargo_config.targets,
                                 &cargo_config.extra_env,
                             )
                         }