1 files changed, 111 insertions, 0 deletions

diff --git a/crates/proc_macro_api/src/lib.rs b/crates/proc_macro_api/src/lib.rs
new file mode 100644
index 000000000..15db57eb2
--- /dev/null
+++ b/crates/proc_macro_api/src/lib.rs
@@ -0,0 +1,111 @@
+//! 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
+//! is used to provide basic infrastructure for communication between two
+//! processes: Client (RA itself), Server (the external program)
+
+mod rpc;
+mod process;
+pub mod msg;
+
+use std::{
+    ffi::OsStr,
+    io,
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+
+use tt::{SmolStr, Subtree};
+
+use crate::process::{ProcMacroProcessSrv, ProcMacroProcessThread};
+
+pub use rpc::{ExpansionResult, ExpansionTask, ListMacrosResult, ListMacrosTask, ProcMacroKind};
+
+#[derive(Debug, Clone)]
+pub struct ProcMacroProcessExpander {
+    process: Arc<ProcMacroProcessSrv>,
+    dylib_path: PathBuf,
+    name: SmolStr,
+}
+
+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 tt::TokenExpander for ProcMacroProcessExpander {
+    fn expand(
+        &self,
+        subtree: &Subtree,
+        _attr: Option<&Subtree>,
+    ) -> Result<Subtree, tt::ExpansionError> {
+        self.process.custom_derive(&self.dylib_path, subtree, &self.name)
+    }
+}
+
+#[derive(Debug)]
+enum ProcMacroClientKind {
+    Process { process: Arc<ProcMacroProcessSrv>, thread: ProcMacroProcessThread },
+    Dummy,
+}
+
+#[derive(Debug)]
+pub struct ProcMacroClient {
+    kind: ProcMacroClientKind,
+}
+
+impl ProcMacroClient {
+    pub fn extern_process(
+        process_path: PathBuf,
+        args: impl IntoIterator<Item = impl AsRef<OsStr>>,
+    ) -> io::Result<ProcMacroClient> {
+        let (thread, process) = ProcMacroProcessSrv::run(process_path, args)?;
+        Ok(ProcMacroClient {
+            kind: ProcMacroClientKind::Process { process: Arc::new(process), thread },
+        })
+    }
+
+    pub fn dummy() -> ProcMacroClient {
+        ProcMacroClient { kind: ProcMacroClientKind::Dummy }
+    }
+
+    pub fn by_dylib_path(&self, dylib_path: &Path) -> Vec<(SmolStr, Arc<dyn tt::TokenExpander>)> {
+        match &self.kind {
+            ProcMacroClientKind::Dummy => vec![],
+            ProcMacroClientKind::Process { process, .. } => {
+                let macros = match process.find_proc_macros(dylib_path) {
+                    Err(err) => {
+                        eprintln!("Failed to find proc macros. Error: {:#?}", err);
+                        return vec![];
+                    }
+                    Ok(macros) => macros,
+                };
+
+                macros
+                    .into_iter()
+                    .filter_map(|(name, kind)| {
+                        // FIXME: Support custom derive only for now.
+                        match kind {
+                            ProcMacroKind::CustomDerive => {
+                                let name = SmolStr::new(&name);
+                                let expander: Arc<dyn tt::TokenExpander> =
+                                    Arc::new(ProcMacroProcessExpander {
+                                        process: process.clone(),
+                                        name: name.clone(),
+                                        dylib_path: dylib_path.into(),
+                                    });
+                                Some((name, expander))
+                            }
+                            _ => None,
+                        }
+                    })
+                    .collect()
+            }
+        }
+    }
+}