Start switching JSON LSP adapter to plugin (take 2)

crates/zed/src/languages.rs

@@ -6,10 +6,11 @@ use std::{borrow::Cow, str, sync::Arc};
 mod c;
 mod go;
 mod installation;
-mod json;
 mod python;
+mod language_plugin;
 mod rust;
 mod typescript;
+// mod json;
 
 #[derive(RustEmbed)]
 #[folder = "src/languages"]
@@ -37,7 +38,7 @@ pub fn build_language_registry(login_shell_env_loaded: Task<()>) -> LanguageRegi
         (
             "json",
             tree_sitter_json::language(),
-            Some(Arc::new(json::JsonLspAdapter)),
+            Some(Arc::new(language_plugin::new_json())),
         ),
         (
             "markdown",

crates/zed/src/languages/json.rs

@@ -24,8 +24,8 @@ impl LspAdapter for JsonLspAdapter {
         LanguageServerName("vscode-json-languageserver".into())
     }
 
-    fn server_args(&self) -> &[&str] {
-        &["--stdio"]
+    fn server_args(&self) -> Vec<String> {
+        vec!["--stdio".into()]
     }
 
     fn fetch_latest_server_version(

crates/zed/src/languages/language_plugin.rs

@@ -0,0 +1,116 @@
+use super::installation::{npm_install_packages, npm_package_latest_version};
+use anyhow::{anyhow, Context, Result};
+use client::http::HttpClient;
+use futures::{future::BoxFuture, FutureExt, StreamExt};
+use language::{LanguageServerName, LspAdapter};
+use parking_lot::{Mutex, RwLock};
+use plugin_runtime::{Runtime, Wasm, WasmPlugin};
+use serde_json::json;
+use smol::fs;
+use std::{any::Any, path::PathBuf, sync::Arc};
+use util::{ResultExt, TryFutureExt};
+
+pub fn new_json() {}
+
+pub struct LanguagePluginLspAdapter {
+    runtime: Mutex<Wasm<()>>,
+}
+
+impl LanguagePluginLspAdapter {
+    pub fn new(plugin: WasmPlugin<()>) -> Self {
+        Self {
+            runtime: Mutex::new(Wasm::init(plugin).unwrap()),
+        }
+    }
+}
+
+struct Versions {
+    language_version: String,
+    server_version: String,
+}
+
+impl LspAdapter for LanguagePluginLspAdapter {
+    fn name(&self) -> LanguageServerName {
+        let name: String = self.runtime.lock().call("name", ()).unwrap();
+        LanguageServerName(name.into())
+    }
+
+    fn server_args<'a>(&'a self) -> Vec<String> {
+        self.runtime.lock().call("args", ()).unwrap()
+    }
+
+    fn fetch_latest_server_version(
+        &self,
+        _: Arc<dyn HttpClient>,
+    ) -> BoxFuture<'static, Result<Box<dyn 'static + Send + Any>>> {
+        let versions: Result<(String, String)> =
+            self.runtime.lock().call("fetch_latest_server_version", ());
+
+        async move {
+            if let Ok((language_version, server_version)) = versions {
+                Ok(Box::new(Versions {
+                    language_version,
+                    server_version,
+                }) as Box<_>)
+            } else {
+                panic!()
+            }
+        }
+        .boxed()
+    }
+
+    fn fetch_server_binary(
+        &self,
+        versions: Box<dyn 'static + Send + Any>,
+        _: Arc<dyn HttpClient>,
+        container_dir: PathBuf,
+    ) -> BoxFuture<'static, Result<PathBuf>> {
+        // TODO: async runtime
+        let result = self
+            .runtime
+            .lock()
+            .call("fetch_server_binary", container_dir);
+        async move { result }.boxed()
+    }
+
+    fn cached_server_binary(&self, container_dir: PathBuf) -> BoxFuture<'static, Option<PathBuf>> {
+        let result = self
+            .runtime
+            .lock()
+            .call("cached_server_binary", container_dir);
+        async move { result }.log_err().boxed()
+    }
+
+    fn process_diagnostics(&self, _: &mut lsp::PublishDiagnosticsParams) {}
+
+    fn label_for_completion(
+        &self,
+        item: &lsp::CompletionItem,
+        language: &language::Language,
+    ) -> Option<language::CodeLabel> {
+        use lsp::CompletionItemKind as Kind;
+        let len = item.label.len();
+        let grammar = language.grammar()?;
+        let kind = format!("{:?}", item.kind?);
+        let name: String = self
+            .runtime
+            .lock()
+            .call("label_for_completion", kind)
+            .ok()?;
+        let highlight_id = grammar.highlight_id_for_name(&name)?;
+        Some(language::CodeLabel {
+            text: item.label.clone(),
+            runs: vec![(0..len, highlight_id)],
+            filter_range: 0..len,
+        })
+    }
+
+    fn initialization_options(&self) -> Option<serde_json::Value> {
+        let result = self
+            .runtime
+            .lock()
+            .call("initialization_options", ())
+            .unwrap();
+        Some(result)
+    }
+}

crates/zed/src/languages/typescript.rs

@@ -28,8 +28,11 @@ impl LspAdapter for TypeScriptLspAdapter {
         LanguageServerName("typescript-language-server".into())
     }
 
-    fn server_args(&self) -> &[&str] {
-        &["--stdio", "--tsserver-path", "node_modules/typescript/lib"]
+    fn server_args(&self) -> Vec<String> {
+        ["--stdio", "--tsserver-path", "node_modules/typescript/lib"]
+            .into_iter()
+            .map(str::to_string)
+            .collect()
     }
 
     fn fetch_latest_server_version(