chore: use more AssertUnwindSafe (unwound accumulators can't hurt us)

Author: davidbarsky

crates/ide-db/src/prime_caches.rs

@@ -74,14 +74,10 @@ pub fn parallel_prime_caches(
     let (work_sender, progress_receiver) = {
         let (progress_sender, progress_receiver) = crossbeam_channel::unbounded();
         let (work_sender, work_receiver) = crossbeam_channel::unbounded();
-        let graph = graph.clone();
-        let local_roots = db.local_roots();
-        let prime_caches_worker = move |db: Snapshot<RootDatabase>| {
-            while let Ok((crate_id, crate_name)) = work_receiver.recv() {
-                progress_sender.send(ParallelPrimeCacheWorkerProgress::BeginCrate {
-                    crate_id,
-                    crate_name,
-                })?;
+        let prime_caches_worker = move |db: RootDatabase| {
+            while let Ok((crate_id, crate_name, kind)) = work_receiver.recv() {
+                progress_sender
+                    .send(ParallelPrimeCacheWorkerProgress::BeginCrate { crate_id, crate_name })?;
 
                 match kind {
                     PrimingPhase::DefMap => _ = db.crate_def_map(crate_id),
@@ -197,7 +193,7 @@ pub fn parallel_prime_caches(
     }
 
     while crates_done < crates_total {
-        db.unwind_if_cancelled();
+        db.unwind_if_revision_cancelled();
 
         // recv_timeout is somewhat a hack, we need a way to from this thread check to see if the current salsa revision
         // is cancelled on a regular basis. workers will only exit if they are processing a task that is cancelled, or
@@ -209,7 +205,7 @@ pub fn parallel_prime_caches(
             }
             Err(crossbeam_channel::RecvTimeoutError::Disconnected) => {
                 // our workers may have died from a cancelled task, so we'll check and re-raise here.
-                db.unwind_if_cancelled();
+                db.unwind_if_revision_cancelled();
                 break;
             }
         };

crates/rust-analyzer/src/cli/rustc_tests.rs

@@ -164,13 +164,13 @@ impl Tester {
                     let analysis = self.host.analysis();
                     let root_file = self.root_file;
                     move || {
-                        let res = std::panic::catch_unwind(move || {
+                        let res = std::panic::catch_unwind(AssertUnwindSafe(move || {
                             analysis.full_diagnostics(
                                 diagnostic_config,
                                 ide::AssistResolveStrategy::None,
                                 root_file,
                             )
-                        });
+                            }));
                         main.unpark();
                         res
                     }

crates/rust-analyzer/src/main_loop.rs

@@ -529,7 +529,7 @@ impl GlobalState {
         let num_worker_threads = self.config.prime_caches_num_threads();
 
         self.task_pool.handle.spawn_with_sender(ThreadIntent::Worker, {
-            let analysis = self.snapshot().analysis;
+            let analysis = AssertUnwindSafe(self.snapshot().analysis);
             move |sender| {
                 sender.send(Task::PrimeCaches(PrimeCachesProgress::Begin)).unwrap();
                 let res = analysis.parallel_prime_caches(num_worker_threads, |progress| {
@@ -910,12 +910,12 @@ impl GlobalState {
             }
             QueuedTask::CheckProcMacroSources(modified_rust_files) => {
                 let crate_graph = self.analysis_host.raw_database().crate_graph();
-                let snap = self.snapshot();
+                let analysis = AssertUnwindSafe(self.snapshot().analysis);
                 self.task_pool.handle.spawn_with_sender(stdx::thread::ThreadIntent::Worker, {
                     move |sender| {
                         if modified_rust_files.into_iter().any(|file_id| {
                             // FIXME: Check whether these files could be build script related
-                            match snap.analysis.crates_for(file_id) {
+                            match analysis.crates_for(file_id) {
                                 Ok(crates) => {
                                     crates.iter().any(|&krate| crate_graph[krate].is_proc_macro)
                                 }