Tidy up async behaviour (#93)

* Disable multi-thread RT

We're not doing anything CPU intensive not lots of filesystem I/O. We
don't need multiple threads.

* Remove pointless blocking task

This task spawns a new thread which takes a blocking lock on a mutex.
Just take a non-blocking lock on the current thread.

* Avoid blocking locks

* Remove unnecessary async/await

* Disable unused tokio features

Author: WhyNotHugo

Cargo.lock

@@ -15,7 +15,7 @@ pin-project-lite = "0.2.14"
 serde = { version = "1.0.186", features = ["derive"] }
 serde_json = "1.0.78"
 time = "0.3.30"
-tokio = { version = "1.37.0", features = ["fs", "io-std", "io-util", "macros", "net", "parking_lot", "process", "rt-multi-thread", "sync", "time"] }
+tokio = { version = "1.37.0", features = ["io-std", "io-util", "macros", "net", "process", "rt", "sync", "time"] }
 toml = "0.5.8"
 tracing = "0.1.39"
 tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }

Cargo.toml

@@ -110,9 +110,7 @@ async fn status(
     instance_map: Arc<Mutex<InstanceMap>>,
     mut writer: LspWriter<OwnedWriteHalf>,
 ) -> Result<()> {
-    let status = task::spawn_blocking(move || instance_map.blocking_lock().get_status())
-        .await
-        .unwrap();
+    let status = instance_map.lock().await.get_status().await;
     writer
         .write_message(&Message::ResponseSuccess(ResponseSuccess {
             jsonrpc: Version,

src/client.rs

@@ -68,8 +68,8 @@ where
     }
 }
 
-pub async fn config(config: &Config) -> Result<()> {
-    println!("{:#?}", config);
+pub fn config(config: &Config) -> Result<()> {
+    println!("{config:#?}");
     Ok(())
 }
 

src/ext.rs

@@ -293,17 +293,19 @@ impl Instance {
         Ok(())
     }
 
-    pub fn get_status(&self) -> ext::Instance {
+    async fn get_status(&self) -> ext::Instance {
         let clients = self
             .clients
-            .blocking_lock()
+            .lock()
+            .await
             .values()
             .map(|client| client.get_status())
             .collect();
 
         let registered_dyn_capabilities = self
             .dynamic_capabilities
-            .blocking_lock()
+            .lock()
+            .await
             .values()
             .map(|reg| reg.method.clone())
             .collect();
@@ -324,7 +326,7 @@ impl Instance {
 pub struct InstanceMap(HashMap<InstanceKey, Arc<Instance>>);
 
 impl InstanceMap {
-    pub async fn new(config: &Config) -> Arc<Mutex<Self>> {
+    pub fn new(config: &Config) -> Arc<Mutex<Self>> {
         let instance_map = Arc::new(Mutex::new(InstanceMap(HashMap::new())));
         task::spawn(gc_task(
             instance_map.clone(),
@@ -344,14 +346,12 @@ impl InstanceMap {
             .map(|(_, inst)| inst.deref())
     }
 
-    pub fn get_status(&self) -> ext::StatusResponse {
-        ext::StatusResponse {
-            instances: self
-                .0
-                .values()
-                .map(|instance| instance.get_status())
-                .collect(),
+    pub async fn get_status(&self) -> ext::StatusResponse {
+        let mut instances = Vec::with_capacity(self.0.len());
+        for instance in self.0.values() {
+            instances.push(instance.get_status().await);
         }
+        ext::StatusResponse { instances }
     }
 }
 

src/instance.rs

@@ -53,7 +53,7 @@ enum Cmd {
     Reload {},
 }
 
-#[tokio::main]
+#[tokio::main(flavor = "current_thread")]
 async fn main() -> Result<()> {
     let cli = Cli::parse();
 
@@ -75,7 +75,7 @@ async fn main() -> Result<()> {
         Some(Cmd::Server {}) => server::run(&config).await,
         Some(Cmd::Client { server, args }) => proxy::run(&config, server, args).await,
         Some(Cmd::Status { json }) => ext::status(&config, json).await,
-        Some(Cmd::Config {}) => ext::config(&config).await,
+        Some(Cmd::Config {}) => ext::config(&config),
         Some(Cmd::Reload {}) => ext::reload(&config).await,
         None => {
             let server_path = env::var("RA_MUX_SERVER").unwrap_or_else(|_| "rust-analyzer".into());

src/main.rs

@@ -10,7 +10,7 @@ use crate::instance::InstanceMap;
 use crate::socketwrapper::Listener;
 
 pub async fn run(config: &Config) -> Result<()> {
-    let instance_map = InstanceMap::new(config).await;
+    let instance_map = InstanceMap::new(config);
     let next_client_id = AtomicUsize::new(0);
     let next_client_id = || next_client_id.fetch_add(1, Ordering::Relaxed);