Merge pull request #20158 from Veykril/push-rquozrwuskry

fix: Do not warn about proc-macro srv when sysroot is missing

crates/load-cargo/src/lib.rs

@@ -78,20 +78,27 @@ pub fn load_workspace(
 
     tracing::debug!(?load_config, "LoadCargoConfig");
     let proc_macro_server = match &load_config.with_proc_macro_server {
-        ProcMacroServerChoice::Sysroot => ws
+        ProcMacroServerChoice::Sysroot => ws.find_sysroot_proc_macro_srv().map(|it| {
-            .find_sysroot_proc_macro_srv()
+            it.and_then(|it| ProcMacroClient::spawn(&it, extra_env).map_err(Into::into)).map_err(
-            .and_then(|it| ProcMacroClient::spawn(&it, extra_env).map_err(Into::into))
+                |e| ProcMacroLoadingError::ProcMacroSrvError(e.to_string().into_boxed_str()),
-            .map_err(|e| ProcMacroLoadingError::ProcMacroSrvError(e.to_string().into_boxed_str())),
+            )
-        ProcMacroServerChoice::Explicit(path) => ProcMacroClient::spawn(path, extra_env)
+        }),
-            .map_err(|e| ProcMacroLoadingError::ProcMacroSrvError(e.to_string().into_boxed_str())),
+        ProcMacroServerChoice::Explicit(path) => {
-        ProcMacroServerChoice::None => Err(ProcMacroLoadingError::Disabled),
+            Some(ProcMacroClient::spawn(path, extra_env).map_err(|e| {
+                ProcMacroLoadingError::ProcMacroSrvError(e.to_string().into_boxed_str())
+            }))
+        }
+        ProcMacroServerChoice::None => Some(Err(ProcMacroLoadingError::Disabled)),
     };
     match &proc_macro_server {
-        Ok(server) => {
+        Some(Ok(server)) => {
-            tracing::info!(path=%server.server_path(), "Proc-macro server started")
+            tracing::info!(manifest=%ws.manifest_or_root(), path=%server.server_path(), "Proc-macro server started")
         }
-        Err(e) => {
+        Some(Err(e)) => {
-            tracing::info!(%e, "Failed to start proc-macro server")
+            tracing::info!(manifest=%ws.manifest_or_root(), %e, "Failed to start proc-macro server")
+        }
+        None => {
+            tracing::info!(manifest=%ws.manifest_or_root(), "No proc-macro server started")
         }
     }
 
@@ -108,8 +115,13 @@ pub fn load_workspace(
     );
     let proc_macros = {
         let proc_macro_server = match &proc_macro_server {
-            Ok(it) => Ok(it),
+            Some(Ok(it)) => Ok(it),
-            Err(e) => Err(ProcMacroLoadingError::ProcMacroSrvError(e.to_string().into_boxed_str())),
+            Some(Err(e)) => {
+                Err(ProcMacroLoadingError::ProcMacroSrvError(e.to_string().into_boxed_str()))
+            }
+            None => Err(ProcMacroLoadingError::ProcMacroSrvError(
+                "proc-macro-srv is not running, workspace is missing a sysroot".into(),
+            )),
         };
         proc_macros
             .into_iter()
@@ -144,7 +156,7 @@ pub fn load_workspace(
     if load_config.prefill_caches {
         prime_caches::parallel_prime_caches(&db, 1, &|_| ());
     }
-    Ok((db, vfs, proc_macro_server.ok()))
+    Ok((db, vfs, proc_macro_server.and_then(Result::ok)))
 }
 
 #[derive(Default)]

crates/project-model/src/sysroot.rs

@@ -163,18 +163,18 @@ impl Sysroot {
         }
     }
 
-    pub fn discover_proc_macro_srv(&self) -> anyhow::Result<AbsPathBuf> {
+    pub fn discover_proc_macro_srv(&self) -> Option<anyhow::Result<AbsPathBuf>> {
-        let Some(root) = self.root() else {
+        let root = self.root()?;
-            return Err(anyhow::format_err!("no sysroot",));
+        Some(
-        };
+            ["libexec", "lib"]
-        ["libexec", "lib"]
+                .into_iter()
-            .into_iter()
+                .map(|segment| root.join(segment).join("rust-analyzer-proc-macro-srv"))
-            .map(|segment| root.join(segment).join("rust-analyzer-proc-macro-srv"))
+                .find_map(|server_path| probe_for_binary(server_path.into()))
-            .find_map(|server_path| probe_for_binary(server_path.into()))
+                .map(AbsPathBuf::assert)
-            .map(AbsPathBuf::assert)
+                .ok_or_else(|| {
-            .ok_or_else(|| {
+                    anyhow::format_err!("cannot find proc-macro server in sysroot `{}`", root)
-                anyhow::format_err!("cannot find proc-macro server in sysroot `{}`", root)
+                }),
-            })
+        )
     }
 
     fn assemble(

crates/project-model/src/workspace.rs

@@ -744,7 +744,7 @@ impl ProjectWorkspace {
         }
     }
 
-    pub fn find_sysroot_proc_macro_srv(&self) -> anyhow::Result<AbsPathBuf> {
+    pub fn find_sysroot_proc_macro_srv(&self) -> Option<anyhow::Result<AbsPathBuf>> {
         self.sysroot.discover_proc_macro_srv()
     }
 

crates/rust-analyzer/src/global_state.rs

@@ -101,7 +101,7 @@ pub(crate) struct GlobalState {
     pub(crate) last_reported_status: lsp_ext::ServerStatusParams,
 
     // proc macros
-    pub(crate) proc_macro_clients: Arc<[anyhow::Result<ProcMacroClient>]>,
+    pub(crate) proc_macro_clients: Arc<[Option<anyhow::Result<ProcMacroClient>>]>,
     pub(crate) build_deps_changed: bool,
 
     // Flycheck

crates/rust-analyzer/src/reload.rs

@@ -194,8 +194,7 @@ impl GlobalState {
                 format_to!(message, "{e}");
             });
 
-            let proc_macro_clients =
+            let proc_macro_clients = self.proc_macro_clients.iter().chain(iter::repeat(&None));
-                self.proc_macro_clients.iter().map(Some).chain(iter::repeat_with(|| None));
 
             for (ws, proc_macro_client) in self.workspaces.iter().zip(proc_macro_clients) {
                 if let ProjectWorkspaceKind::Cargo { error: Some(error), .. }
@@ -252,7 +251,8 @@ impl GlobalState {
                             message.push_str("\n\n");
                         }
                     }
-                    _ => (),
+                    // sysroot was explicitly not set so we didn't discover a server
+                    None => {}
                 }
             }
         }
@@ -419,14 +419,11 @@ impl GlobalState {
             };
 
             let mut builder = ProcMacrosBuilder::default();
-            let proc_macro_clients = proc_macro_clients
+            let proc_macro_clients = proc_macro_clients.iter().chain(iter::repeat(&None));
-                .iter()
-                .map(|res| res.as_ref().map_err(|e| e.to_string()))
-                .chain(iter::repeat_with(|| Err("proc-macro-srv is not running".into())));
             for (client, paths) in proc_macro_clients.zip(paths) {
                 for (crate_id, res) in paths.iter() {
                     let expansion_res = match client {
-                        Ok(client) => match res {
+                        Some(Ok(client)) => match res {
                             Ok((crate_name, path)) => {
                                 progress(format!("loading proc-macros: {path}"));
                                 let ignored_proc_macros = ignored_proc_macros
@@ -440,8 +437,11 @@ impl GlobalState {
                             }
                             Err(e) => Err(e.clone()),
                         },
-                        Err(ref e) => Err(ProcMacroLoadingError::ProcMacroSrvError(
+                        Some(Err(e)) => Err(ProcMacroLoadingError::ProcMacroSrvError(
-                            e.clone().into_boxed_str(),
+                            e.to_string().into_boxed_str(),
+                        )),
+                        None => Err(ProcMacroLoadingError::ProcMacroSrvError(
+                            "proc-macro-srv is not running".into(),
                         )),
                     };
                     builder.insert(*crate_id, expansion_res)
@@ -657,7 +657,10 @@ impl GlobalState {
             self.proc_macro_clients = Arc::from_iter(self.workspaces.iter().map(|ws| {
                 let path = match self.config.proc_macro_srv() {
                     Some(path) => path,
-                    None => ws.find_sysroot_proc_macro_srv()?,
+                    None => match ws.find_sysroot_proc_macro_srv()? {
+                        Ok(path) => path,
+                        Err(e) => return Some(Err(e)),
+                    },
                 };
 
                 let env: FxHashMap<_, _> = match &ws.kind {
@@ -684,14 +687,14 @@ impl GlobalState {
                 };
                 info!("Using proc-macro server at {path}");
 
-                ProcMacroClient::spawn(&path, &env).map_err(|err| {
+                Some(ProcMacroClient::spawn(&path, &env).map_err(|err| {
                     tracing::error!(
                         "Failed to run proc-macro server from path {path}, error: {err:?}",
                     );
                     anyhow::format_err!(
                         "Failed to run proc-macro server from path {path}, error: {err:?}",
                     )
-                })
+                }))
             }))
         }