Rust: add option for proc macro server

Author: Paolo Tranquilli

rust/extractor/src/config.rs

@@ -13,14 +13,15 @@ use num_traits::Zero;
 use ra_ap_cfg::{CfgAtom, CfgDiff};
 use ra_ap_ide_db::FxHashMap;
 use ra_ap_intern::Symbol;
+use ra_ap_load_cargo::{LoadCargoConfig, ProcMacroServerChoice};
 use ra_ap_paths::{AbsPath, AbsPathBuf, Utf8PathBuf};
 use ra_ap_project_model::{CargoConfig, CargoFeatures, CfgOverrides, RustLibSource, Sysroot};
 use rust_extractor_macros::extractor_cli_config;
 use serde::{Deserialize, Serialize};
 use std::collections::HashSet;
 use std::fmt::Debug;
 use std::ops::Not;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 #[derive(Debug, PartialEq, Eq, Default, Serialize, Deserialize, Clone, Copy, clap::ValueEnum)]
 #[serde(rename_all = "lowercase")]
@@ -64,6 +65,7 @@ pub struct Config {
     pub rustc_src: Option<PathBuf>,
     pub build_script_command: Vec<String>,
     pub extra_includes: Vec<PathBuf>,
+    pub proc_macro_server: Option<PathBuf>,
 }
 
 impl Config {
@@ -93,70 +95,87 @@ impl Config {
         figment.extract().context("loading configuration")
     }
 
-    pub fn to_cargo_config(&self, dir: &AbsPath) -> CargoConfig {
-        let path_buf_to_abs_path_buf = |path: &PathBuf| {
-            let Ok(path) = Utf8PathBuf::from_path_buf(path.clone()) else {
-                panic!("non utf8 input: {}", path.display())
-            };
-            dir.join(path)
-        };
-        let sysroot_input = self.sysroot.as_ref().map(path_buf_to_abs_path_buf);
-        let sysroot_src_input = self.sysroot_src.as_ref().map(path_buf_to_abs_path_buf);
-        let rustc_src_input = self.rustc_src.as_ref().map(path_buf_to_abs_path_buf);
-
-        let sysroot = match (sysroot_input, sysroot_src_input) {
+    fn sysroot(&self, dir: &AbsPath) -> Sysroot {
+        let sysroot_input = self.sysroot.as_ref().map(|p| join_path_buf(dir, p));
+        let sysroot_src_input = self.sysroot_src.as_ref().map(|p| join_path_buf(dir, p));
+        match (sysroot_input, sysroot_src_input) {
             (None, None) => Sysroot::discover(dir, &self.cargo_extra_env),
             (Some(sysroot), None) => Sysroot::discover_sysroot_src_dir(sysroot),
             (None, Some(sysroot_src)) => {
                 Sysroot::discover_with_src_override(dir, &self.cargo_extra_env, sysroot_src)
             }
             (Some(sysroot), Some(sysroot_src)) => Sysroot::new(Some(sysroot), Some(sysroot_src)),
-        };
-        CargoConfig {
-            all_targets: self.cargo_all_targets,
-            sysroot_src: sysroot.src_root().map(ToOwned::to_owned),
-            rustc_source: rustc_src_input
-                .or_else(|| sysroot.discover_rustc_src().map(AbsPathBuf::from))
-                .map(RustLibSource::Path),
-            sysroot: sysroot
-                .root()
-                .map(ToOwned::to_owned)
-                .map(RustLibSource::Path),
+        }
+    }
 
-            extra_env: self.cargo_extra_env.clone(),
-            extra_args: self.cargo_extra_args.clone(),
-            extra_includes: self
-                .extra_includes
-                .iter()
-                .map(path_buf_to_abs_path_buf)
-                .collect(),
-            target_dir: Utf8PathBuf::from_path_buf(
-                self.cargo_target_dir
-                    .clone()
-                    .unwrap_or_else(|| self.scratch_dir.join("target")),
-            )
-            .ok(),
-            features: if self.cargo_features.is_empty() {
-                Default::default()
-            } else if self.cargo_features.contains(&"*".to_string()) {
-                CargoFeatures::All
-            } else {
-                CargoFeatures::Selected {
-                    features: self.cargo_features.clone(),
-                    no_default_features: false,
-                }
+    fn proc_macro_server_choice(&self, dir: &AbsPath) -> ProcMacroServerChoice {
+        match &self.proc_macro_server {
+            Some(path) => match path.to_str() {
+                Some("none") => ProcMacroServerChoice::None,
+                Some("sysroot") => ProcMacroServerChoice::Sysroot,
+                _ => ProcMacroServerChoice::Explicit(join_path_buf(dir, path)),
             },
-            target: self.cargo_target.clone(),
-            cfg_overrides: to_cfg_overrides(&self.cargo_cfg_overrides),
-            wrap_rustc_in_build_scripts: false,
-            run_build_script_command: if self.build_script_command.is_empty() {
-                None
-            } else {
-                Some(self.build_script_command.clone())
-            },
-            ..Default::default()
+            None => ProcMacroServerChoice::Sysroot,
         }
     }
+
+    pub fn to_cargo_config(&self, dir: &AbsPath) -> (CargoConfig, LoadCargoConfig) {
+        let sysroot = self.sysroot(dir);
+        (
+            CargoConfig {
+                all_targets: self.cargo_all_targets,
+                sysroot_src: sysroot.src_root().map(ToOwned::to_owned),
+                rustc_source: self
+                    .rustc_src
+                    .as_ref()
+                    .map(|p| join_path_buf(dir, p))
+                    .or_else(|| sysroot.discover_rustc_src().map(AbsPathBuf::from))
+                    .map(RustLibSource::Path),
+                sysroot: sysroot
+                    .root()
+                    .map(ToOwned::to_owned)
+                    .map(RustLibSource::Path),
+
+                extra_env: self.cargo_extra_env.clone(),
+                extra_args: self.cargo_extra_args.clone(),
+                extra_includes: self
+                    .extra_includes
+                    .iter()
+                    .map(|p| join_path_buf(dir, p))
+                    .collect(),
+                target_dir: Utf8PathBuf::from_path_buf(
+                    self.cargo_target_dir
+                        .clone()
+                        .unwrap_or_else(|| self.scratch_dir.join("target")),
+                )
+                .ok(),
+                features: if self.cargo_features.is_empty() {
+                    Default::default()
+                } else if self.cargo_features.contains(&"*".to_string()) {
+                    CargoFeatures::All
+                } else {
+                    CargoFeatures::Selected {
+                        features: self.cargo_features.clone(),
+                        no_default_features: false,
+                    }
+                },
+                target: self.cargo_target.clone(),
+                cfg_overrides: to_cfg_overrides(&self.cargo_cfg_overrides),
+                wrap_rustc_in_build_scripts: false,
+                run_build_script_command: if self.build_script_command.is_empty() {
+                    None
+                } else {
+                    Some(self.build_script_command.clone())
+                },
+                ..Default::default()
+            },
+            LoadCargoConfig {
+                load_out_dirs_from_check: true,
+                with_proc_macro_server: self.proc_macro_server_choice(dir),
+                prefill_caches: false,
+            },
+        )
+    }
 }
 
 fn to_cfg_override(spec: &str) -> CfgAtom {
@@ -194,3 +213,10 @@ fn to_cfg_overrides(specs: &Vec<String>) -> CfgOverrides {
         ..Default::default()
     }
 }
+
+fn join_path_buf(lhs: &AbsPath, rhs: &Path) -> AbsPathBuf {
+    let Ok(path) = Utf8PathBuf::from_path_buf(rhs.into()) else {
+        panic!("non utf8 input: {}", rhs.display())
+    };
+    lhs.join(path)
+}

rust/extractor/src/main.rs

@@ -7,6 +7,7 @@ use log::{info, warn};
 use ra_ap_hir::Semantics;
 use ra_ap_ide_db::line_index::{LineCol, LineIndex};
 use ra_ap_ide_db::RootDatabase;
+use ra_ap_load_cargo::LoadCargoConfig;
 use ra_ap_paths::{AbsPathBuf, Utf8PathBuf};
 use ra_ap_project_model::{CargoConfig, ProjectManifest};
 use ra_ap_vfs::Vfs;
@@ -112,9 +113,10 @@ impl<'a> Extractor<'a> {
         &mut self,
         project: &ProjectManifest,
         config: &CargoConfig,
+        load_config: &LoadCargoConfig,
     ) -> Option<(RootDatabase, Vfs)> {
         let before = Instant::now();
-        let ret = RustAnalyzer::load_workspace(project, config);
+        let ret = RustAnalyzer::load_workspace(project, config, load_config);
         self.steps
             .push(ExtractionStep::load_manifest(before, project));
         ret
@@ -221,9 +223,12 @@ fn main() -> anyhow::Result<()> {
         }
         extractor.extract_without_semantics(file, "no manifest found");
     }
-    let cargo_config = cfg.to_cargo_config(&cwd()?);
+    let cwd = cwd()?;
+    let (cargo_config, load_cargo_config) = cfg.to_cargo_config(&cwd);
     for (manifest, files) in map.values().filter(|(_, files)| !files.is_empty()) {
-        if let Some((ref db, ref vfs)) = extractor.load_manifest(manifest, &cargo_config) {
+        if let Some((ref db, ref vfs)) =
+            extractor.load_manifest(manifest, &cargo_config, &load_cargo_config)
+        {
             let semantics = Semantics::new(db);
             for file in files {
                 match extractor.load_source(file, &semantics, vfs) {

rust/extractor/src/rust_analyzer.rs

@@ -3,7 +3,7 @@ use log::{debug, error, info, warn};
 use ra_ap_base_db::SourceDatabase;
 use ra_ap_hir::Semantics;
 use ra_ap_ide_db::RootDatabase;
-use ra_ap_load_cargo::{load_workspace_at, LoadCargoConfig, ProcMacroServerChoice};
+use ra_ap_load_cargo::{load_workspace_at, LoadCargoConfig};
 use ra_ap_paths::Utf8PathBuf;
 use ra_ap_project_model::ProjectManifest;
 use ra_ap_project_model::{CargoConfig, ManifestPath};
@@ -50,16 +50,12 @@ impl<'a> RustAnalyzer<'a> {
     pub fn load_workspace(
         project: &ProjectManifest,
         config: &CargoConfig,
+        load_config: &LoadCargoConfig,
     ) -> Option<(RootDatabase, Vfs)> {
         let progress = |t| (log::trace!("progress: {}", t));
-        let load_config = LoadCargoConfig {
-            load_out_dirs_from_check: true,
-            with_proc_macro_server: ProcMacroServerChoice::Sysroot,
-            prefill_caches: false,
-        };
         let manifest = project.manifest_path();
 
-        match load_workspace_at(manifest.as_ref(), config, &load_config, &progress) {
+        match load_workspace_at(manifest.as_ref(), config, load_config, &progress) {
             Ok((db, vfs, _macro_server)) => Some((db, vfs)),
             Err(err) => {
                 log::error!("failed to load workspace for {}: {}", manifest, err);