vue 3 comms initial idea working

Co-authored-by: MrSubidubi <dev@bahn.sh>

assets/settings/default.json

@@ -1744,7 +1744,7 @@
       "use_on_type_format": false
     },
     "Vue.js": {
-      "language_servers": ["vue-language-server", "..."],
+      "language_servers": ["vue-language-server", "vtsls", "..."],
       "prettier": {
         "allowed": true
       }

crates/language/src/language.rs

@@ -283,10 +283,16 @@ impl CachedLspAdapter {
     }
 
     pub fn language_id(&self, language_name: &LanguageName) -> String {
-        self.language_ids
+        let candidate = self
+            .language_ids
             .get(language_name)
             .cloned()
-            .unwrap_or_else(|| language_name.lsp_id())
+            .unwrap_or_else(|| language_name.lsp_id());
+        if candidate == "vue.js" {
+            "vue".into()
+        } else {
+            candidate
+        }
     }
 }
 

crates/lsp/src/lsp.rs

@@ -355,6 +355,7 @@ impl LanguageServer {
         let stdin = server.stdin.take().unwrap();
         let stdout = server.stdout.take().unwrap();
         let stderr = server.stderr.take().unwrap();
+        let name_for_logging = server_name.clone();
         let server = Self::new_internal(
             server_id,
             server_name,
@@ -370,7 +371,8 @@ impl LanguageServer {
             cx,
             move |notification| {
                 log::info!(
-                    "Language server with id {} sent unhandled notification {}:\n{}",
+                    "Language server `{}` with id {} sent unhandled notification {}:\n{}",
+                    name_for_logging.0,
                     server_id,
                     notification.method,
                     serde_json::to_string_pretty(&notification.params).unwrap(),
@@ -868,7 +870,7 @@ impl LanguageServer {
                     ..WindowClientCapabilities::default()
                 }),
             },
-            trace: None,
+            trace: Some(TraceValue::Verbose),
             workspace_folders: Some(workspace_folders),
             client_info: release_channel::ReleaseChannel::try_global(cx).map(|release_channel| {
                 ClientInfo {

crates/project/src/lsp_store.rs

@@ -14,6 +14,7 @@ pub mod json_language_server_ext;
 pub mod log_store;
 pub mod lsp_ext_command;
 pub mod rust_analyzer_ext;
+pub mod vue_language_server_ext;
 
 use crate::{
     CodeAction, ColorPresentation, Completion, CompletionDisplayOptions, CompletionResponse,
@@ -992,6 +993,7 @@ impl LocalLspStore {
             })
             .detach();
 
+        vue_language_server_ext::register_requests(this.clone(), language_server);
         json_language_server_ext::register_requests(this.clone(), language_server);
         rust_analyzer_ext::register_notifications(this.clone(), language_server);
         clangd_ext::register_notifications(this, language_server, adapter);

crates/project/src/lsp_store/vue_language_server_ext.rs

@@ -0,0 +1,82 @@
+use anyhow::Context as _;
+use gpui::{AppContext, WeakEntity};
+use lsp::{LanguageServer, LanguageServerName};
+use serde_json::json;
+
+use crate::LspStore;
+
+struct VueServerRequest;
+struct TypescriptServerResponse;
+
+impl lsp::notification::Notification for VueServerRequest {
+    type Params = [(u64, String, serde_json::Value); 1];
+
+    const METHOD: &'static str = "tsserver/request";
+}
+
+impl lsp::notification::Notification for TypescriptServerResponse {
+    type Params = serde_json::Value;
+
+    const METHOD: &'static str = "tsserver/response";
+}
+
+const VUE_SERVER_NAME: LanguageServerName = LanguageServerName::new_static("vue-language-server");
+const VTSLS: LanguageServerName = LanguageServerName::new_static("vtsls");
+const TS_LS: LanguageServerName = LanguageServerName::new_static("typescript-language-server");
+
+pub fn register_requests(lsp_store: WeakEntity<LspStore>, language_server: &LanguageServer) {
+    let language_server_name = language_server.name();
+    if language_server_name == VUE_SERVER_NAME {
+        let vue_server_id = language_server.server_id();
+        language_server
+            .on_notification::<VueServerRequest, _>({
+                let this = lsp_store.clone();
+                move |params, cx| {
+                    let this = this.clone();
+                    let Ok(target_server) = this
+                        .read_with(cx, |this, _| {
+                            let language_server_id = this
+                                .as_local()
+                                .and_then(|local| {
+                                    local.language_server_ids.iter().find_map(|(seed, v)| {
+                                        [VTSLS, TS_LS].contains(&seed.name).then_some(v.id)
+                                    })
+                                })
+                                .context("Could not find language server")?;
+
+                            this.language_server_for_id(language_server_id)
+                                .context("language server not found")
+                        })
+                        .flatten()
+                    else {
+                        return;
+                    };
+                    let Some(vue_server) = this
+                        .read_with(cx, |this, _| this.language_server_for_id(vue_server_id))
+                        .ok()
+                        .flatten()
+                    else {
+                        return;
+                    };
+                    let cx = cx.clone();
+                    cx.background_spawn(async move {
+                        let (request_id, command, arguments) = params[0].clone();
+                        let tsserver_response = target_server
+                            .request::<lsp::request::ExecuteCommand>(lsp::ExecuteCommandParams {
+                                command: "typescript.tsserverRequest".to_owned(),
+                                arguments: vec![serde_json::Value::String(command), arguments],
+                                ..Default::default()
+                            })
+                            .await;
+                        if let util::ConnectionResult::Result(Ok(result)) = tsserver_response {
+                            _ = vue_server.notify::<TypescriptServerResponse>(
+                                &json!({ "id": request_id, "response": result }),
+                            );
+                        }
+                    })
+                    .detach();
+                }
+            })
+            .detach();
+    }
+}