Explicitly name all spawned threads

The thread name is shown in debugger as well as panic messages and this
patch makes it easier to follow a thread instead of looking through
full backtrace, by naming all spawned threads according to their
functioning.

crates/flycheck/src/lib.rs

@@ -67,7 +67,10 @@ impl FlycheckHandle {
     ) -> FlycheckHandle {
         let actor = FlycheckActor::new(id, sender, config, workspace_root);
         let (sender, receiver) = unbounded::<Restart>();
-        let thread = jod_thread::spawn(move || actor.run(receiver));
+        let thread = jod_thread::Builder::new()
+            .name("FlycheckThread".to_owned())
+            .spawn(move || actor.run(receiver))
+            .expect("failed to spawn thread");
         FlycheckHandle { sender, thread }
     }
 
@@ -266,7 +269,10 @@ impl CargoHandle {
         let child_stdout = child.stdout.take().unwrap();
         let (sender, receiver) = unbounded();
         let actor = CargoActor::new(child_stdout, sender);
-        let thread = jod_thread::spawn(move || actor.run());
+        let thread = jod_thread::Builder::new()
+            .name("CargoHandleThread".to_owned())
+            .spawn(move || actor.run())
+            .expect("failed to spawn thread");
         CargoHandle { child, thread, receiver }
     }
     fn join(mut self) -> io::Result<()> {

crates/proc_macro_api/src/process.rs

@@ -37,9 +37,12 @@ impl ProcMacroProcessSrv {
         let process = Process::run(process_path, args)?;
 
         let (task_tx, task_rx) = bounded(0);
-        let handle = jod_thread::spawn(move || {
+        let handle = jod_thread::Builder::new()
+            .name("ProcMacroClientThread".to_owned())
+            .spawn(move || {
                 client_loop(task_rx, process);
-        });
+            })
+            .expect("failed to spawn thread");
 
         let task_tx = Arc::new(task_tx);
         let srv = ProcMacroProcessSrv { inner: Arc::downgrade(&task_tx) };

crates/proc_macro_srv/src/proc_macro/bridge/server.rs

@@ -181,7 +181,9 @@ impl ExecutionStrategy for CrossThread1 {
         let (req_tx, req_rx) = channel();
         let (res_tx, res_rx) = channel();
 
-        let join_handle = thread::spawn(move || {
+        let join_handle = thread::Builder::new()
+            .name("DispatchThread".to_owned())
+            .spawn(move || {
                 let mut dispatch = |b| {
                     req_tx.send(b).unwrap();
                     res_rx.recv().unwrap()
@@ -195,7 +197,8 @@ impl ExecutionStrategy for CrossThread1 {
                     },
                     client_data,
                 )
-        });
+            })
+            .expect("failed to spawn thread");
 
         for b in req_rx {
             res_tx.send(dispatcher.dispatch(b)).unwrap();
@@ -227,7 +230,9 @@ impl ExecutionStrategy for CrossThread2 {
 
         let server_thread = thread::current();
         let state2 = state.clone();
-        let join_handle = thread::spawn(move || {
+        let join_handle = thread::Builder::new()
+            .name("ServerThread".to_owned())
+            .spawn(move || {
                 let mut dispatch = |b| {
                     *state2.lock().unwrap() = State::Req(b);
                     server_thread.unpark();
@@ -253,7 +258,8 @@ impl ExecutionStrategy for CrossThread2 {
                 server_thread.unpark();
 
                 r
-        });
+            })
+            .expect("failed to spawn thread");
 
         // Check whether `state2` was dropped, to know when to stop.
         while Arc::get_mut(&mut state).is_none() {

crates/vfs-notify/src/lib.rs

@@ -31,7 +31,10 @@ impl loader::Handle for NotifyHandle {
     fn spawn(sender: loader::Sender) -> NotifyHandle {
         let actor = NotifyActor::new(sender);
         let (sender, receiver) = unbounded::<Message>();
-        let thread = jod_thread::spawn(move || actor.run(receiver));
+        let thread = jod_thread::Builder::new()
+            .name("LoaderThread".to_owned())
+            .spawn(move || actor.run(receiver))
+            .expect("failed to spawn thread");
         NotifyHandle { sender, thread }
     }
     fn set_config(&mut self, config: loader::Config) {