rust/crates/proc_macro_api/src/lib.rs

139 lines
4.5 KiB
Rust
Raw Normal View History

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;
mod process;
mod rpc;
mod version;
2020-03-26 15:26:34 -05:00
2020-12-11 07:57:50 -06:00
use base_db::{Env, ProcMacro};
use std::{
ffi::OsStr,
io,
path::{Path, PathBuf},
2021-07-12 08:19:53 -05:00
sync::{Arc, Mutex},
};
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};
pub use version::{read_dylib_info, RustCInfo};
2020-03-26 15:26:34 -05:00
#[derive(Debug, Clone)]
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)
}
}
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,
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> {
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(),
};
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))?;
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
}
pub fn by_dylib_path(&self, dylib_path: &Path) -> Vec<ProcMacro> {
let _p = profile::span("ProcMacroClient::by_dylib_path");
match version::read_dylib_info(dylib_path) {
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)
{
Err(err) => {
eprintln!("Failed to find proc macros. Error: {:#?}", err);
return vec![];
2020-03-26 15:26:34 -05: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,
};
let expander = Arc::new(ProcMacroProcessExpander {
process: self.process.clone(),
name: name.clone(),
dylib_path: dylib_path.into(),
});
ProcMacro { name, kind, expander }
})
.collect()
2020-03-18 04:47:59 -05:00
}
}