Fix config guard lock for ratoml tests

Author: Veykril

crates/load-cargo/src/lib.rs

@@ -156,7 +156,7 @@ impl ProjectFolders {
     pub fn new(
         workspaces: &[ProjectWorkspace],
         global_excludes: &[AbsPathBuf],
-        user_config_dir_path: Option<&'static AbsPath>,
+        user_config_dir_path: Option<&AbsPath>,
     ) -> ProjectFolders {
         let mut res = ProjectFolders::default();
         let mut fsc = FileSetConfig::builder();
@@ -302,7 +302,7 @@ impl ProjectFolders {
                 p
             };
 
-            let file_set_roots: Vec<VfsPath> = vec![VfsPath::from(ratoml_path.to_owned())];
+            let file_set_roots = vec![VfsPath::from(ratoml_path.to_owned())];
             let entry = vfs::loader::Entry::Files(vec![ratoml_path.to_owned()]);
 
             res.watch.push(res.load.len());

crates/rust-analyzer/src/config.rs

@@ -1254,7 +1254,7 @@ pub struct NotificationsConfig {
     pub cargo_toml_not_found: bool,
 }
 
-#[derive(Deserialize, Serialize, Debug, Clone)]
+#[derive(Debug, Clone)]
 pub enum RustfmtConfig {
     Rustfmt { extra_args: Vec<String>, enable_range_formatting: bool },
     CustomCommand { command: String, args: Vec<String> },

crates/rust-analyzer/src/global_state.rs

@@ -392,13 +392,13 @@ impl GlobalState {
             || !self.config.same_source_root_parent_map(&self.local_roots_parent_map)
         {
             let config_change = {
-                let user_config_path = {
-                    let mut p = Config::user_config_dir_path().unwrap().to_path_buf();
+                let user_config_path = (|| {
+                    let mut p = Config::user_config_dir_path()?.to_path_buf();
                     p.push("rust-analyzer.toml");
-                    p
-                };
+                    Some(p)
+                })();
 
-                let user_config_abs_path = Some(user_config_path.as_path());
+                let user_config_abs_path = user_config_path.as_deref();
 
                 let mut change = ConfigChange::default();
                 let db = self.analysis_host.raw_database();

crates/rust-analyzer/tests/slow-tests/ratoml.rs

@@ -20,6 +20,7 @@ struct RatomlTest {
     urls: Vec<Url>,
     server: Server,
     tmp_path: Utf8PathBuf,
+    config_locked: bool,
 }
 
 impl RatomlTest {
@@ -65,13 +66,14 @@ impl RatomlTest {
 
         let server = project.server_with_lock(prelock).wait_until_workspace_is_loaded();
 
-        let mut case = Self { urls: vec![], server, tmp_path };
-        let urls = fixtures.iter().map(|fixture| case.fixture_path(fixture)).collect::<Vec<_>>();
+        let mut case = Self { urls: vec![], server, tmp_path, config_locked: prelock };
+        let urls =
+            fixtures.iter().map(|fixture| case.fixture_path(fixture, prelock)).collect::<Vec<_>>();
         case.urls = urls;
         case
     }
 
-    fn fixture_path(&self, fixture: &str) -> Url {
+    fn fixture_path(&self, fixture: &str, prelock: bool) -> Url {
         let mut lines = fixture.trim().split('\n');
 
         let mut path =
@@ -89,6 +91,7 @@ impl RatomlTest {
         let mut spl = spl.into_iter();
         if let Some(first) = spl.next() {
             if first == "$$CONFIG_DIR$$" {
+                assert!(prelock, "this test requires prelock to be set");
                 path = Config::user_config_dir_path().unwrap().to_path_buf().into();
             } else {
                 path = path.join(first);
@@ -109,7 +112,7 @@ impl RatomlTest {
     }
 
     fn create(&mut self, fixture_path: &str, text: String) {
-        let url = self.fixture_path(fixture_path);
+        let url = self.fixture_path(fixture_path, self.config_locked);
 
         self.server.notification::<DidOpenTextDocument>(DidOpenTextDocumentParams {
             text_document: TextDocumentItem {

crates/rust-analyzer/tests/slow-tests/support.rs

@@ -1,7 +1,7 @@
 use std::{
     cell::{Cell, RefCell},
     env, fs,
-    sync::Once,
+    sync::{Once, OnceLock},
     time::Duration,
 };
 
@@ -141,12 +141,17 @@ impl Project<'_> {
     /// file in the config dir after server is run, something where our naive approach comes short.
     /// Using a `prelock` allows us to force a lock when we know we need it.
     pub(crate) fn server_with_lock(self, prelock: bool) -> Server {
-        static CONFIG_DIR_LOCK: Mutex<()> = Mutex::new(());
+        static CONFIG_DIR_LOCK: OnceLock<Mutex<()>> = OnceLock::new();
 
         let mut config_dir_guard = if prelock {
-            let v = Some(CONFIG_DIR_LOCK.lock());
-            env::set_var("__TEST_RA_USER_CONFIG_DIR", TestDir::new().path());
-            v
+            Some(
+                CONFIG_DIR_LOCK
+                    .get_or_init(|| {
+                        env::set_var("__TEST_RA_USER_CONFIG_DIR", TestDir::new().keep().path());
+                        Mutex::new(())
+                    })
+                    .lock(),
+            )
         } else {
             None
         };
@@ -185,10 +190,7 @@ impl Project<'_> {
 
         for entry in fixture {
             if let Some(pth) = entry.path.strip_prefix("/$$CONFIG_DIR$$") {
-                if config_dir_guard.is_none() {
-                    config_dir_guard = Some(CONFIG_DIR_LOCK.lock());
-                    env::set_var("__TEST_RA_USER_CONFIG_DIR", TestDir::new().path());
-                }
+                assert!(config_dir_guard.is_some(), "this test requires prelock to be set to true");
 
                 let path = Config::user_config_dir_path().unwrap().join(&pth['/'.len_utf8()..]);
                 fs::create_dir_all(path.parent().unwrap()).unwrap();