2020-03-18 07:56:46 -05:00
|
|
|
//! Client-side Proc-Macro crate
|
|
|
|
//!
|
|
|
|
//! We separate proc-macro expanding logic to an extern program to allow
|
|
|
|
//! different implementations (e.g. wasm or dylib loading). And this crate
|
2020-04-20 13:26:10 -05:00
|
|
|
//! is used to provide basic infrastructure for communication between two
|
2020-03-25 21:49:23 -05:00
|
|
|
//! processes: Client (RA itself), Server (the external program)
|
2020-03-18 07:56:46 -05:00
|
|
|
|
2020-03-26 15:26:34 -05:00
|
|
|
pub mod msg;
|
2020-12-11 08:14:42 -06:00
|
|
|
mod process;
|
|
|
|
mod rpc;
|
2021-03-03 20:48:12 -06:00
|
|
|
mod version;
|
2020-03-26 15:26:34 -05:00
|
|
|
|
2020-12-11 07:57:50 -06:00
|
|
|
use base_db::{Env, ProcMacro};
|
2020-12-23 07:24:53 -06:00
|
|
|
use std::{
|
|
|
|
ffi::OsStr,
|
2021-03-03 20:48:12 -06:00
|
|
|
io,
|
2020-12-23 07:24:53 -06:00
|
|
|
path::{Path, PathBuf},
|
2021-07-12 08:19:53 -05:00
|
|
|
sync::{Arc, Mutex},
|
2020-12-23 07:24:53 -06:00
|
|
|
};
|
|
|
|
|
2020-08-12 09:46:20 -05:00
|
|
|
use tt::{SmolStr, Subtree};
|
|
|
|
|
2021-07-08 09:40:14 -05:00
|
|
|
use crate::process::ProcMacroProcessSrv;
|
2020-08-12 09:46:20 -05:00
|
|
|
|
2020-04-01 00:11:26 -05:00
|
|
|
pub use rpc::{ExpansionResult, ExpansionTask, ListMacrosResult, ListMacrosTask, ProcMacroKind};
|
2021-03-15 10:38:22 -05:00
|
|
|
pub use version::{read_dylib_info, RustCInfo};
|
2020-03-26 15:26:34 -05:00
|
|
|
|
|
|
|
#[derive(Debug, Clone)]
|
2020-12-07 07:11:17 -06:00
|
|
|
struct ProcMacroProcessExpander {
|
2021-07-12 08:19:53 -05:00
|
|
|
process: Arc<Mutex<ProcMacroProcessSrv>>,
|
2020-03-26 15:26:34 -05:00
|
|
|
dylib_path: PathBuf,
|
2020-03-26 11:41:44 -05:00
|
|
|
name: SmolStr,
|
2020-03-18 07:56:46 -05:00
|
|
|
}
|
|
|
|
|
2020-03-26 15:26:34 -05:00
|
|
|
impl Eq for ProcMacroProcessExpander {}
|
|
|
|
impl PartialEq for ProcMacroProcessExpander {
|
|
|
|
fn eq(&self, other: &Self) -> bool {
|
|
|
|
self.name == other.name
|
|
|
|
&& self.dylib_path == other.dylib_path
|
|
|
|
&& Arc::ptr_eq(&self.process, &other.process)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-12-11 07:24:02 -06:00
|
|
|
impl base_db::ProcMacroExpander for ProcMacroProcessExpander {
|
2020-03-26 11:41:44 -05:00
|
|
|
fn expand(
|
2020-03-18 07:56:46 -05:00
|
|
|
&self,
|
2020-03-26 15:26:34 -05:00
|
|
|
subtree: &Subtree,
|
2020-12-07 06:55:41 -06:00
|
|
|
attr: Option<&Subtree>,
|
2020-12-11 07:57:50 -06:00
|
|
|
env: &Env,
|
2020-08-12 09:46:20 -05:00
|
|
|
) -> Result<Subtree, tt::ExpansionError> {
|
2020-12-07 06:55:41 -06:00
|
|
|
let task = ExpansionTask {
|
|
|
|
macro_body: subtree.clone(),
|
|
|
|
macro_name: self.name.to_string(),
|
|
|
|
attributes: attr.cloned(),
|
|
|
|
lib: self.dylib_path.to_path_buf(),
|
2020-12-11 07:57:50 -06:00
|
|
|
env: env.iter().map(|(k, v)| (k.to_string(), v.to_string())).collect(),
|
2020-12-07 06:55:41 -06:00
|
|
|
};
|
|
|
|
|
2021-07-12 08:19:53 -05:00
|
|
|
let result: ExpansionResult = self
|
|
|
|
.process
|
|
|
|
.lock()
|
|
|
|
.unwrap_or_else(|e| e.into_inner())
|
|
|
|
.send_task(msg::Request::ExpansionMacro(task))?;
|
2020-12-07 06:55:41 -06:00
|
|
|
Ok(result.expansion)
|
2020-03-18 07:56:46 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-26 23:55:58 -05:00
|
|
|
#[derive(Debug)]
|
2020-03-26 15:26:34 -05:00
|
|
|
pub struct ProcMacroClient {
|
2021-07-12 08:19:53 -05:00
|
|
|
/// Currently, the proc macro process expands all procedural macros sequentially.
|
|
|
|
///
|
|
|
|
/// That means that concurrent salsa requests may block each other when expanding proc macros,
|
|
|
|
/// which is unfortunate, but simple and good enough for the time being.
|
|
|
|
///
|
|
|
|
/// Therefore, we just wrap the `ProcMacroProcessSrv` in a mutex here.
|
|
|
|
process: Arc<Mutex<ProcMacroProcessSrv>>,
|
2020-03-26 15:26:34 -05:00
|
|
|
}
|
|
|
|
|
2020-03-18 07:56:46 -05:00
|
|
|
impl ProcMacroClient {
|
2021-07-08 09:40:14 -05:00
|
|
|
/// Spawns an external process as the proc macro server and returns a client connected to it.
|
2020-04-20 13:26:10 -05:00
|
|
|
pub fn extern_process(
|
|
|
|
process_path: PathBuf,
|
|
|
|
args: impl IntoIterator<Item = impl AsRef<OsStr>>,
|
|
|
|
) -> io::Result<ProcMacroClient> {
|
2021-07-08 09:40:14 -05:00
|
|
|
let process = ProcMacroProcessSrv::run(process_path, args)?;
|
2021-07-12 08:19:53 -05:00
|
|
|
Ok(ProcMacroClient { process: Arc::new(Mutex::new(process)) })
|
2020-03-18 07:56:46 -05:00
|
|
|
}
|
|
|
|
|
2020-12-07 10:06:14 -06:00
|
|
|
pub fn by_dylib_path(&self, dylib_path: &Path) -> Vec<ProcMacro> {
|
2021-04-22 13:25:29 -05:00
|
|
|
let _p = profile::span("ProcMacroClient::by_dylib_path");
|
2021-03-15 10:38:22 -05:00
|
|
|
match version::read_dylib_info(dylib_path) {
|
2021-03-03 20:48:12 -06:00
|
|
|
Ok(info) => {
|
|
|
|
if info.version.0 < 1 || info.version.1 < 47 {
|
|
|
|
eprintln!("proc-macro {} built by {:#?} is not supported by Rust Analyzer, please update your rust version.", dylib_path.to_string_lossy(), info);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Err(err) => {
|
|
|
|
eprintln!(
|
|
|
|
"proc-macro {} failed to find the given version. Reason: {}",
|
|
|
|
dylib_path.to_string_lossy(),
|
|
|
|
err
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-07-12 08:19:53 -05:00
|
|
|
let macros = match self
|
|
|
|
.process
|
|
|
|
.lock()
|
|
|
|
.unwrap_or_else(|e| e.into_inner())
|
|
|
|
.find_proc_macros(dylib_path)
|
|
|
|
{
|
2020-12-07 10:16:50 -06:00
|
|
|
Err(err) => {
|
|
|
|
eprintln!("Failed to find proc macros. Error: {:#?}", err);
|
|
|
|
return vec![];
|
2020-03-26 15:26:34 -05:00
|
|
|
}
|
2020-12-07 10:16:50 -06:00
|
|
|
Ok(macros) => macros,
|
|
|
|
};
|
|
|
|
|
|
|
|
macros
|
|
|
|
.into_iter()
|
|
|
|
.map(|(name, kind)| {
|
|
|
|
let name = SmolStr::new(&name);
|
|
|
|
let kind = match kind {
|
|
|
|
ProcMacroKind::CustomDerive => base_db::ProcMacroKind::CustomDerive,
|
|
|
|
ProcMacroKind::FuncLike => base_db::ProcMacroKind::FuncLike,
|
|
|
|
ProcMacroKind::Attr => base_db::ProcMacroKind::Attr,
|
|
|
|
};
|
2020-12-11 07:24:02 -06:00
|
|
|
let expander = Arc::new(ProcMacroProcessExpander {
|
2020-12-07 10:16:50 -06:00
|
|
|
process: self.process.clone(),
|
|
|
|
name: name.clone(),
|
|
|
|
dylib_path: dylib_path.into(),
|
|
|
|
});
|
|
|
|
|
2020-12-24 09:00:59 -06:00
|
|
|
ProcMacro { name, kind, expander }
|
2020-12-07 10:16:50 -06:00
|
|
|
})
|
|
|
|
.collect()
|
2020-03-18 04:47:59 -05:00
|
|
|
}
|
|
|
|
}
|