1 files changed, 49 insertions, 30 deletions

diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/reload.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/reload.rs
index eaab275bc..e47f70fff 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/reload.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/reload.rs
@@ -196,10 +196,7 @@ impl GlobalState {
         }
 
         if let Err(error) = self.fetch_build_data_error() {
-            self.show_and_log_error(
-                "rust-analyzer failed to run build scripts".to_string(),
-                Some(error),
-            );
+            self.show_and_log_error("failed to run build scripts".to_string(), Some(error));
         }
 
         let workspaces = self
@@ -222,6 +219,7 @@ impl GlobalState {
                     cfg_overrides,
 
                     build_scripts: _,
+                    toolchain: _,
                 } => Some((cargo, sysroot, rustc, rustc_cfg, cfg_overrides)),
                 _ => None,
             };
@@ -308,6 +306,7 @@ impl GlobalState {
 
         if self.proc_macro_clients.is_empty() {
             if let Some((path, args)) = self.config.proc_macro_srv() {
+                tracing::info!("Spawning proc-macro servers");
                 self.proc_macro_clients = self
                     .workspaces
                     .iter()
@@ -315,21 +314,23 @@ impl GlobalState {
                         let mut args = args.clone();
                         let mut path = path.clone();
 
-                        if let ProjectWorkspace::Cargo { sysroot, .. } = ws {
-                            tracing::info!("Found a cargo workspace...");
+                        if let ProjectWorkspace::Cargo { sysroot, .. }
+                        | ProjectWorkspace::Json { sysroot, .. } = ws
+                        {
+                            tracing::debug!("Found a cargo workspace...");
                             if let Some(sysroot) = sysroot.as_ref() {
-                                tracing::info!("Found a cargo workspace with a sysroot...");
+                                tracing::debug!("Found a cargo workspace with a sysroot...");
                                 let server_path =
                                     sysroot.root().join("libexec").join(&standalone_server_name);
                                 if std::fs::metadata(&server_path).is_ok() {
-                                    tracing::info!(
+                                    tracing::debug!(
                                         "And the server exists at {}",
                                         server_path.display()
                                     );
                                     path = server_path;
                                     args = vec![];
                                 } else {
-                                    tracing::info!(
+                                    tracing::debug!(
                                         "And the server does not exist at {}",
                                         server_path.display()
                                     );
@@ -337,14 +338,10 @@ impl GlobalState {
                             }
                         }
 
-                        tracing::info!(
-                            "Using proc-macro server at {} with args {:?}",
-                            path.display(),
-                            args
-                        );
+                        tracing::info!(?args, "Using proc-macro server at {}", path.display(),);
                         ProcMacroServer::spawn(path.clone(), args.clone()).map_err(|err| {
                             let error = format!(
-                                "Failed to run proc_macro_srv from path {}, error: {:?}",
+                                "Failed to run proc-macro server from path {}, error: {:?}",
                                 path.display(),
                                 err
                             );
@@ -352,8 +349,8 @@ impl GlobalState {
                             error
                         })
                     })
-                    .collect();
-            }
+                    .collect()
+            };
         }
 
         let watch = match files_config.watcher {
@@ -458,7 +455,7 @@ impl GlobalState {
             Some(it) => it,
             None => {
                 self.flycheck = Vec::new();
-                self.diagnostics.clear_check();
+                self.diagnostics.clear_check_all();
                 return;
             }
         };
@@ -621,7 +618,10 @@ pub(crate) fn load_proc_macro(
         };
         let expander: Arc<dyn ProcMacroExpander> =
             if dummy_replace.iter().any(|replace| &**replace == name) {
-                Arc::new(DummyExpander)
+                match kind {
+                    ProcMacroKind::Attr => Arc::new(IdentityExpander),
+                    _ => Arc::new(EmptyExpander),
+                }
             } else {
                 Arc::new(Expander(expander))
             };
@@ -647,11 +647,11 @@ pub(crate) fn load_proc_macro(
         }
     }
 
-    /// Dummy identity expander, used for proc-macros that are deliberately ignored by the user.
+    /// Dummy identity expander, used for attribute proc-macros that are deliberately ignored by the user.
     #[derive(Debug)]
-    struct DummyExpander;
+    struct IdentityExpander;
 
-    impl ProcMacroExpander for DummyExpander {
+    impl ProcMacroExpander for IdentityExpander {
         fn expand(
             &self,
             subtree: &tt::Subtree,
@@ -661,27 +661,46 @@ pub(crate) fn load_proc_macro(
             Ok(subtree.clone())
         }
     }
+
+    /// Empty expander, used for proc-macros that are deliberately ignored by the user.
+    #[derive(Debug)]
+    struct EmptyExpander;
+
+    impl ProcMacroExpander for EmptyExpander {
+        fn expand(
+            &self,
+            _: &tt::Subtree,
+            _: Option<&tt::Subtree>,
+            _: &Env,
+        ) -> Result<tt::Subtree, ProcMacroExpansionError> {
+            Ok(tt::Subtree::default())
+        }
+    }
 }
 
 pub(crate) fn should_refresh_for_change(path: &AbsPath, change_kind: ChangeKind) -> bool {
     const IMPLICIT_TARGET_FILES: &[&str] = &["build.rs", "src/main.rs", "src/lib.rs"];
     const IMPLICIT_TARGET_DIRS: &[&str] = &["src/bin", "examples", "tests", "benches"];
-    let file_name = path.file_name().unwrap_or_default();
 
-    if file_name == "Cargo.toml" || file_name == "Cargo.lock" {
+    let file_name = match path.file_name().unwrap_or_default().to_str() {
+        Some(it) => it,
+        None => return false,
+    };
+
+    if let "Cargo.toml" | "Cargo.lock" = file_name {
         return true;
     }
     if change_kind == ChangeKind::Modify {
         return false;
     }
+
+    // .cargo/config{.toml}
     if path.extension().unwrap_or_default() != "rs" {
-        if (file_name == "config.toml" || file_name == "config")
-            && path.parent().map(|parent| parent.as_ref().ends_with(".cargo")) == Some(true)
-        {
-            return true;
-        }
-        return false;
+        let is_cargo_config = matches!(file_name, "config.toml" | "config")
+            && path.parent().map(|parent| parent.as_ref().ends_with(".cargo")).unwrap_or(false);
+        return is_cargo_config;
     }
+
     if IMPLICIT_TARGET_FILES.iter().any(|it| path.as_ref().ends_with(it)) {
         return true;
     }