remove internal callbacks, and move callback to rust-analyzer level

Author: Shourya742

.github/workflows/ci.yaml

@@ -71,9 +71,8 @@ jobs:
       - name: Test
         run: cargo test --features sysroot-abi -p proc-macro-srv -p proc-macro-srv-cli -p proc-macro-api -- --quiet
 
-      # FIXME: This is temporarily disable, more info: https://rust-lang.zulipchat.com/#narrow/channel/185405-t-compiler.2Frust-analyzer/topic/Non-generic.20spans/with/564604549
-      # - name: Check salsa dependency
-      #   run: "! (cargo tree -p proc-macro-srv-cli | grep -q salsa)"
+      - name: Check salsa dependency
+        run: "! (cargo tree -p proc-macro-srv-cli | grep -q salsa)"
 
   rust:
     if: github.repository == 'rust-lang/rust-analyzer'

Cargo.lock

@@ -23,11 +23,17 @@ use ide_db::{
     prime_caches,
 };
 use itertools::Itertools;
-use proc_macro_api::{MacroDylib, ProcMacroClient};
+use proc_macro_api::{
+    MacroDylib, ProcMacroClient,
+    bidirectional_protocol::{
+        msg::{SubRequest, SubResponse},
+        reject_subrequests,
+    },
+};
 use project_model::{CargoConfig, PackageRoot, ProjectManifest, ProjectWorkspace};
 use span::Span;
 use vfs::{
-    AbsPath, AbsPathBuf, VfsPath,
+    AbsPath, AbsPathBuf, FileId, VfsPath,
     file_set::FileSetConfig,
     loader::{Handle, LoadingProgress},
 };
@@ -427,7 +433,7 @@ pub fn load_proc_macro(
 ) -> ProcMacroLoadResult {
     let res: Result<Vec<_>, _> = (|| {
         let dylib = MacroDylib::new(path.to_path_buf());
-        let vec = server.load_dylib(dylib).map_err(|e| {
+        let vec = server.load_dylib(dylib, Some(&mut reject_subrequests)).map_err(|e| {
             ProcMacroLoadingError::ProcMacroSrvError(format!("{e}").into_boxed_str())
         })?;
         if vec.is_empty() {
@@ -533,15 +539,23 @@ impl ProcMacroExpander for Expander {
         mixed_site: Span,
         current_dir: String,
     ) -> Result<tt::TopSubtree<Span>, ProcMacroExpansionError> {
+        let mut cb = |req| match req {
+            SubRequest::SourceText { file_id, start, end } => {
+                let file = FileId::from_raw(file_id);
+                let text = db.file_text(file).text(db);
+                let slice = text.get(start as usize..end as usize).map(ToOwned::to_owned);
+                Ok(SubResponse::SourceTextResult { text: slice })
+            }
+        };
         match self.0.expand(
-            db,
             subtree.view(),
             attrs.map(|attrs| attrs.view()),
             env.clone().into(),
             def_site,
             call_site,
             mixed_site,
             current_dir,
+            Some(&mut cb),
         ) {
             Ok(Ok(subtree)) => Ok(subtree),
             Ok(Err(err)) => Err(ProcMacroExpansionError::Panic(err)),

crates/load-cargo/src/lib.rs

@@ -19,7 +19,6 @@ serde_json = { workspace = true, features = ["unbounded_depth"] }
 tracing.workspace = true
 rustc-hash.workspace = true
 indexmap.workspace = true
-base-db.workspace = true
 
 # local deps
 paths = { workspace = true, features = ["serde1"] }

crates/proc-macro-api/Cargo.toml

@@ -5,9 +5,8 @@ use std::{
     sync::Arc,
 };
 
-use base_db::SourceDatabase;
 use paths::AbsPath;
-use span::{FileId, Span};
+use span::Span;
 
 use crate::{
     Codec, ProcMacro, ProcMacroKind, ServerError,
@@ -29,16 +28,14 @@ use crate::{
 
 pub mod msg;
 
-pub trait ClientCallbacks {
-    fn handle_sub_request(&mut self, req: SubRequest) -> Result<SubResponse, ServerError>;
-}
+pub type SubCallback<'a> = &'a mut dyn FnMut(SubRequest) -> Result<SubResponse, ServerError>;
 
 pub fn run_conversation<C: Codec>(
     writer: &mut dyn Write,
     reader: &mut dyn BufRead,
     buf: &mut C::Buf,
     msg: BidirectionalMessage,
-    callbacks: &mut dyn ClientCallbacks,
+    callback: SubCallback<'_>,
 ) -> Result<BidirectionalMessage, ServerError> {
     let encoded = C::encode(&msg).map_err(wrap_encode)?;
     C::write(writer, &encoded).map_err(wrap_io("failed to write initial request"))?;
@@ -59,7 +56,7 @@ pub fn run_conversation<C: Codec>(
                 return Ok(BidirectionalMessage::Response(response));
             }
             BidirectionalMessage::SubRequest(sr) => {
-                let resp = callbacks.handle_sub_request(sr)?;
+                let resp = callback(sr)?;
                 let reply = BidirectionalMessage::SubResponse(resp);
                 let encoded = C::encode(&reply).map_err(wrap_encode)?;
                 C::write(writer, &encoded).map_err(wrap_io("failed to write sub-response"))?;
@@ -86,19 +83,13 @@ fn wrap_decode(err: io::Error) -> ServerError {
     ServerError { message: "failed to decode message".into(), io: Some(Arc::new(err)) }
 }
 
-pub(crate) fn version_check(srv: &ProcMacroServerProcess) -> Result<u32, ServerError> {
+pub(crate) fn version_check(
+    srv: &ProcMacroServerProcess,
+    callback: SubCallback<'_>,
+) -> Result<u32, ServerError> {
     let request = BidirectionalMessage::Request(Request::ApiVersionCheck {});
 
-    struct NoCallbacks;
-    impl ClientCallbacks for NoCallbacks {
-        fn handle_sub_request(&mut self, _req: SubRequest) -> Result<SubResponse, ServerError> {
-            Err(ServerError { message: "sub-request not supported here".into(), io: None })
-        }
-    }
-
-    let mut callbacks = NoCallbacks;
-
-    let response_payload = run_request(srv, request, &mut callbacks)?;
+    let response_payload = run_request(srv, request, callback)?;
 
     match response_payload {
         BidirectionalMessage::Response(Response::ApiVersionCheck(version)) => Ok(version),
@@ -111,21 +102,13 @@ pub(crate) fn version_check(srv: &ProcMacroServerProcess) -> Result<u32, ServerE
 /// Enable support for rust-analyzer span mode if the server supports it.
 pub(crate) fn enable_rust_analyzer_spans(
     srv: &ProcMacroServerProcess,
+    callback: SubCallback<'_>,
 ) -> Result<SpanMode, ServerError> {
     let request = BidirectionalMessage::Request(Request::SetConfig(ServerConfig {
         span_mode: SpanMode::RustAnalyzer,
     }));
 
-    struct NoCallbacks;
-    impl ClientCallbacks for NoCallbacks {
-        fn handle_sub_request(&mut self, _req: SubRequest) -> Result<SubResponse, ServerError> {
-            Err(ServerError { message: "sub-request not supported here".into(), io: None })
-        }
-    }
-
-    let mut callbacks = NoCallbacks;
-
-    let response_payload = run_request(srv, request, &mut callbacks)?;
+    let response_payload = run_request(srv, request, callback)?;
 
     match response_payload {
         BidirectionalMessage::Response(Response::SetConfig(ServerConfig { span_mode })) => {
@@ -139,21 +122,13 @@ pub(crate) fn enable_rust_analyzer_spans(
 pub(crate) fn find_proc_macros(
     srv: &ProcMacroServerProcess,
     dylib_path: &AbsPath,
+    callback: SubCallback<'_>,
 ) -> Result<Result<Vec<(String, ProcMacroKind)>, String>, ServerError> {
     let request = BidirectionalMessage::Request(Request::ListMacros {
         dylib_path: dylib_path.to_path_buf().into(),
     });
 
-    struct NoCallbacks;
-    impl ClientCallbacks for NoCallbacks {
-        fn handle_sub_request(&mut self, _req: SubRequest) -> Result<SubResponse, ServerError> {
-            Err(ServerError { message: "sub-request not supported here".into(), io: None })
-        }
-    }
-
-    let mut callbacks = NoCallbacks;
-
-    let response_payload = run_request(srv, request, &mut callbacks)?;
+    let response_payload = run_request(srv, request, callback)?;
 
     match response_payload {
         BidirectionalMessage::Response(Response::ListMacros(it)) => Ok(it),
@@ -163,14 +138,14 @@ pub(crate) fn find_proc_macros(
 
 pub(crate) fn expand(
     proc_macro: &ProcMacro,
-    db: &dyn SourceDatabase,
     subtree: tt::SubtreeView<'_, Span>,
     attr: Option<tt::SubtreeView<'_, Span>>,
     env: Vec<(String, String)>,
     def_site: Span,
     call_site: Span,
     mixed_site: Span,
     current_dir: String,
+    callback: SubCallback<'_>,
 ) -> Result<Result<tt::TopSubtree<span::SpanData<span::SyntaxContext>>, String>, crate::ServerError>
 {
     let version = proc_macro.process.version();
@@ -201,27 +176,7 @@ pub(crate) fn expand(
         current_dir: Some(current_dir),
     })));
 
-    struct Callbacks<'de> {
-        db: &'de dyn SourceDatabase,
-    }
-    impl<'db> ClientCallbacks for Callbacks<'db> {
-        fn handle_sub_request(&mut self, req: SubRequest) -> Result<SubResponse, ServerError> {
-            match req {
-                SubRequest::SourceText { file_id, start, end } => {
-                    let file = FileId::from_raw(file_id);
-                    let text = self.db.file_text(file).text(self.db);
-
-                    let slice = text.get(start as usize..end as usize).map(|s| s.to_owned());
-
-                    Ok(SubResponse::SourceTextResult { text: slice })
-                }
-            }
-        }
-    }
-
-    let mut callbacks = Callbacks { db };
-
-    let response_payload = run_request(&proc_macro.process, task, &mut callbacks)?;
+    let response_payload = run_request(&proc_macro.process, task, callback)?;
 
     match response_payload {
         BidirectionalMessage::Response(Response::ExpandMacro(it)) => Ok(it
@@ -253,15 +208,19 @@ pub(crate) fn expand(
 fn run_request(
     srv: &ProcMacroServerProcess,
     msg: BidirectionalMessage,
-    callbacks: &mut dyn ClientCallbacks,
+    callback: SubCallback<'_>,
 ) -> Result<BidirectionalMessage, ServerError> {
     if let Some(server_error) = srv.exited() {
         return Err(server_error.clone());
     }
 
     if srv.use_postcard() {
-        srv.run_bidirectional::<PostcardProtocol>(msg, callbacks)
+        srv.run_bidirectional::<PostcardProtocol>(msg, callback)
     } else {
-        srv.run_bidirectional::<JsonProtocol>(msg, callbacks)
+        srv.run_bidirectional::<JsonProtocol>(msg, callback)
     }
 }
+
+pub fn reject_subrequests(req: SubRequest) -> Result<SubResponse, ServerError> {
+    Err(ServerError { message: format!("{req:?} sub-request not supported here"), io: None })
+}

crates/proc-macro-api/src/bidirectional_protocol.rs

@@ -7,7 +7,6 @@ use std::{
     sync::Arc,
 };
 
-use base_db::SourceDatabase;
 use paths::AbsPath;
 use span::Span;
 
@@ -78,7 +77,6 @@ pub(crate) fn find_proc_macros(
 
 pub(crate) fn expand(
     proc_macro: &ProcMacro,
-    _db: &dyn SourceDatabase,
     subtree: tt::SubtreeView<'_, Span>,
     attr: Option<tt::SubtreeView<'_, Span>>,
     env: Vec<(String, String)>,

crates/proc-macro-api/src/legacy_protocol.rs

@@ -21,14 +21,13 @@ pub mod legacy_protocol;
 mod process;
 pub mod transport;
 
-use base_db::SourceDatabase;
 use paths::{AbsPath, AbsPathBuf};
 use semver::Version;
 use span::{ErasedFileAstId, FIXUP_ERASED_FILE_AST_ID_MARKER, Span};
 use std::{fmt, io, sync::Arc, time::SystemTime};
 
-use crate::process::ProcMacroServerProcess;
 pub use crate::transport::codec::Codec;
+use crate::{bidirectional_protocol::SubCallback, process::ProcMacroServerProcess};
 
 /// The versions of the server protocol
 pub mod version {
@@ -143,9 +142,13 @@ impl ProcMacroClient {
     }
 
     /// Loads a proc-macro dylib into the server process returning a list of `ProcMacro`s loaded.
-    pub fn load_dylib(&self, dylib: MacroDylib) -> Result<Vec<ProcMacro>, ServerError> {
+    pub fn load_dylib(
+        &self,
+        dylib: MacroDylib,
+        callback: Option<SubCallback<'_>>,
+    ) -> Result<Vec<ProcMacro>, ServerError> {
         let _p = tracing::info_span!("ProcMacroServer::load_dylib").entered();
-        let macros = self.process.find_proc_macros(&dylib.path)?;
+        let macros = self.process.find_proc_macros(&dylib.path, callback)?;
 
         let dylib_path = Arc::new(dylib.path);
         let dylib_last_modified = std::fs::metadata(dylib_path.as_path())
@@ -219,14 +222,14 @@ impl ProcMacro {
     /// This includes span information and environmental context.
     pub fn expand(
         &self,
-        db: &dyn SourceDatabase,
         subtree: tt::SubtreeView<'_, Span>,
         attr: Option<tt::SubtreeView<'_, Span>>,
         env: Vec<(String, String)>,
         def_site: Span,
         call_site: Span,
         mixed_site: Span,
         current_dir: String,
+        callback: Option<SubCallback<'_>>,
     ) -> Result<Result<tt::TopSubtree<Span>, String>, ServerError> {
         let (mut subtree, mut attr) = (subtree, attr);
         let (mut subtree_changed, mut attr_changed);
@@ -243,7 +246,6 @@ impl ProcMacro {
         }
 
         self.process.expand(
-            db,
             self,
             subtree,
             attr,
@@ -252,6 +254,7 @@ impl ProcMacro {
             call_site,
             mixed_site,
             current_dir,
+            callback,
         )
     }
 }