rename

Author: sxlijin

engine/language_server/src/lib.rs

@@ -2,7 +2,7 @@ use std::num::NonZeroUsize;
 
 use anyhow::Context;
 pub use edit::{DocumentKey, PositionEncoding, TextDocument};
-use playground_server::{Orwie12Message, Reofji32Message};
+use playground_server::{WebviewNotification, WebviewRouterMessage};
 pub use session::{ClientSettings, DocumentQuery, DocumentSnapshot, Session};
 use tokio::sync::broadcast;
 
@@ -34,8 +34,8 @@ pub(crate) fn version() -> &'static str {
 pub fn run_server() -> anyhow::Result<()> {
     let tokio_runtime = tokio::runtime::Runtime::new()?;
 
-    let (reofji32_tx, reofji32_rx) = broadcast::channel(1000);
-    let (orwie12_tx, orwie12_rx) = broadcast::channel(1000);
+    let (webview_router_to_websocket_tx, webview_router_to_websocket_rx) = broadcast::channel(1000);
+    let (webview_router_input_tx, webview_router_input_rx) = broadcast::channel(1000);
 
     let port_config = playground_server::PortConfiguration {
         base_port: 3700,
@@ -44,16 +44,15 @@ pub fn run_server() -> anyhow::Result<()> {
     let port_picks = tokio_runtime.block_on(playground_server::pick_ports(port_config))?;
 
     {
-        let reofji32_tx = reofji32_tx.clone();
-        let orwie12_tx = orwie12_tx.clone();
+        let webview_router_to_websocket_tx = webview_router_to_websocket_tx.clone();
+        let webview_router_input_tx = webview_router_input_tx.clone();
         tokio_runtime.spawn(futures::future::join(
             async move {
                 eprintln!("Playground server started");
                 let server = playground_server::PlaygroundServer {
                     app_state: playground_server::AppState {
-                        reofji32_tx,
-                        reofji32_rx,
-                        orwie12_tx: orwie12_tx.clone(),
+                        webview_router_to_websocket_rx: webview_router_to_websocket_rx,
+                        webview_router_input_tx: webview_router_input_tx.clone(),
                         playground_port: port_picks.playground_port,
                         proxy_port: port_picks.proxy_port,
                         editor_config: std::sync::Arc::new(std::sync::RwLock::new(
@@ -93,9 +92,9 @@ pub fn run_server() -> anyhow::Result<()> {
         worker_threads,
         ServerArgs {
             tokio_runtime,
-            reofji32_tx,
-            orwie12_rx,
-            orwie12_tx: orwie12_tx.clone(),
+            webview_router_to_websocket_tx,
+            webview_router_input_rx,
+            webview_router_input_tx: webview_router_input_tx.clone(),
             playground_port: port_picks.playground_port,
             proxy_port: port_picks.proxy_port,
         },

engine/language_server/src/server.rs

@@ -19,7 +19,7 @@ use lsp_types::{
     TextDocumentSyncKind, TextDocumentSyncOptions, TextDocumentSyncSaveOptions, Url,
     WorkspaceClientCapabilities, WorkspaceFoldersServerCapabilities, WorkspaceServerCapabilities,
 };
-use playground_server::{FrontendMessage, Orwie12Message, Reofji32Message};
+use playground_server::{FrontendMessage, WebviewNotification, WebviewRouterMessage};
 use schedule::Task;
 use serde::{Deserialize, Serialize};
 use serde_json::json;
@@ -49,9 +49,9 @@ pub type Result<T> = std::result::Result<T, api::Error>;
 
 pub(crate) struct ServerArgs {
     pub tokio_runtime: tokio::runtime::Runtime,
-    pub reofji32_tx: broadcast::Sender<Reofji32Message>,
-    pub orwie12_rx: broadcast::Receiver<Orwie12Message>,
-    pub orwie12_tx: broadcast::Sender<Orwie12Message>,
+    pub webview_router_to_websocket_tx: broadcast::Sender<WebviewNotification>,
+    pub webview_router_input_rx: broadcast::Receiver<WebviewRouterMessage>,
+    pub webview_router_input_tx: broadcast::Sender<WebviewRouterMessage>,
     pub playground_port: u16,
     pub proxy_port: u16,
 }
@@ -176,8 +176,8 @@ impl Server {
             global_settings,
             &workspaces,
             args.playground_port,
-            args.orwie12_tx.clone(),
-            args.reofji32_tx.clone(),
+            args.webview_router_input_tx.clone(),
+            args.webview_router_to_websocket_tx.clone(),
             client_version,
         )?;
 
@@ -209,16 +209,32 @@ impl Server {
             });
         }
         {
+            // Start the webview router loop
+            //
+            // This is the communication bridge between the webview and IDE in non-VSCode environments
+            // and allows the webview to send messages to Jetbrains and allows Jetbrains to send messages
+            // to the webview.
+            //
+            // webview->IDE is generally backed by the webview POSTing to /webview/SEND_LSP_NOTIFICATION_TO_IDE,
+            //   and the language server will then forward that to the IDE
+            // IDE->webview is generally backed by the IDE calling POST /webview/SEND_LSP_NOTIFICATION_TO_WEBVIEW,
+            //   and the language server will then forward that to the webview
+            //
+            // (Note that although the language-server pretends to offer a request-response API, it does not
+            // block on either the IDE or webview responding before responding to its caller.)
+            //
+            // Incoming messages are received via webview_router_input_tx, which the router will then decide to
+            // dispatch to either the webview (via its websocket) or the IDE (via its LSP connection).
             let lsp_sender = server.connection.make_sender();
-            let mut orwie12_rx = server.args.orwie12_rx.resubscribe();
-            let reofji32_tx = server.args.reofji32_tx.clone();
+            let mut webview_router_input_rx = server.args.webview_router_input_rx.resubscribe();
+            let webview_router_to_websocket_tx = server.args.webview_router_to_websocket_tx.clone();
             let session = server.session.clone();
             server.args.tokio_runtime.spawn(async move {
                 tracing::info!("Starting playground rx loop");
-                while let Ok(msg) = orwie12_rx.recv().await {
+                while let Ok(msg) = webview_router_input_rx.recv().await {
                     tracing::info!("playground rx loop: {:?}", msg);
                     match msg {
-                        Orwie12Message::WasmIsInitialized => {
+                        WebviewRouterMessage::WasmIsInitialized => {
                             tracing::info!("Received playground INITIALIZED request");
                             let projects = session.baml_src_projects.lock();
                             for (_, project) in projects.iter() {
@@ -239,8 +255,8 @@ impl Server {
                                         (key, contents)
                                     })
                                     .collect();
-                                let _ = reofji32_tx
-                                    .send(Reofji32Message::PlaygroundMessage(
+                                let _ = webview_router_to_websocket_tx
+                                    .send(WebviewNotification::PlaygroundMessage(
                                         FrontendMessage::add_project {
                                             root_path: project
                                                 .root_path()
@@ -254,18 +270,18 @@ impl Server {
                                     });
                             }
                         }
-                        Orwie12Message::SendLspNotificationToIde(notification) => {
+                        WebviewRouterMessage::SendLspNotificationToIde(notification) => {
                             tracing::info!("Received playground SEND_LSP_NOTIFICATION request: {:?}", notification);
                             let _ = lsp_sender
                                 .send(Message::Notification(notification))
                                 .inspect_err(|e| {
                                     tracing::error!("Failed to forward SEND_LSP_NOTIFICATION message to language-server: {e}");
                                 });
                         }
-                        Orwie12Message::SendLspNotificationToWebview(notification) => {
+                        WebviewRouterMessage::SendLspNotificationToWebview(notification) => {
                             tracing::info!("Received playground SEND_LSP_NOTIFICATION_TO_WEBVIEW request: {:?}", notification);
-                            let _ = reofji32_tx
-                                .send(Reofji32Message::PlaygroundMessage(
+                            let _ = webview_router_to_websocket_tx
+                                .send(WebviewNotification::PlaygroundMessage(
                                     FrontendMessage::lsp_message {
                                         method: notification.method,
                                         params: notification.params,
@@ -275,9 +291,9 @@ impl Server {
                                     tracing::error!("Failed to forward SEND_LSP_NOTIFICATION_TO_WEBVIEW message to webview: {e}");
                                 });
                         }
-                        Orwie12Message::FrontendMessage(msg) => {
-                            let _ = reofji32_tx
-                                .send(Reofji32Message::PlaygroundMessage(msg))
+                        WebviewRouterMessage::FrontendMessage(msg) => {
+                            let _ = webview_router_to_websocket_tx
+                                .send(WebviewNotification::PlaygroundMessage(msg))
                                 .inspect_err(|e| {
                                     tracing::error!("Failed to forward FrontendMessage to playground: {e}");
                                 });
@@ -366,7 +382,7 @@ impl Server {
                 &self.client_capabilities,
                 self.session,
                 self.worker_threads,
-                self.args.reofji32_tx,
+                self.args.webview_router_to_websocket_tx,
             )?;
             self.connection.close()?;
             Ok(())
@@ -382,7 +398,7 @@ impl Server {
         _client_capabilities: &ClientCapabilities,
         mut session: Session,
         worker_threads: NonZeroUsize,
-        reofji32_tx: broadcast::Sender<Reofji32Message>,
+        webview_router_to_websocket_tx: broadcast::Sender<WebviewNotification>,
     ) -> anyhow::Result<()> {
         // Ensure we have a notifier for reload operations
         let client = client::Client::new(connection.make_sender());
@@ -398,7 +414,7 @@ impl Server {
             if connection.handle_shutdown(&msg)? {
                 break;
             }
-            // reofji32_tx.send(LangServerToWasmMessage::LspMessage(msg.clone()))?;
+            // webview_router_to_websocket_tx.send(LangServerToWasmMessage::LspMessage(msg.clone()))?;
             let tasks = match msg {
                 Message::Request(req) => vec![api::request(req)],
                 Message::Notification(notification) => api::notification(notification),

engine/language_server/src/server/api/notifications/did_change.rs

@@ -3,7 +3,7 @@ use std::{collections::HashMap, time::Instant};
 use lsp_types::{
     notification::DidChangeTextDocument, DidChangeTextDocumentParams, PublishDiagnosticsParams,
 };
-use playground_server::{FrontendMessage, Orwie12Message};
+use playground_server::{FrontendMessage, WebviewRouterMessage};
 
 use crate::{
     server::{
@@ -84,8 +84,8 @@ impl SyncNotificationHandler for DidChangeTextDocumentHandler {
                 })
                 .collect();
             session
-                .orwie12_tx
-                .send(Orwie12Message::FrontendMessage(
+                .webview_router_input_tx
+                .send(WebviewRouterMessage::FrontendMessage(
                     FrontendMessage::add_project {
                         root_path: project.root_path().to_string_lossy().to_string(),
                         files: files_map,

engine/language_server/src/server/api/requests/code_action.rs

@@ -33,7 +33,7 @@ impl SyncRequestHandler for CodeActionHandler {
         // TODO: this is the only way to do this in zed i think
         // tracing::info!("CodeActionHandler running");
         // let _ = session
-        //     .reofji32_tx
+        //     .webview_router_to_websocket_tx
         //     .send(
         //         playground_server::LangServerToWasmMessage::PlaygroundMessage(
         //             playground_server::FrontendMessage::lsp_message {

engine/language_server/src/server/api/requests/execute_command.rs

@@ -2,7 +2,7 @@ use std::time::Duration;
 
 use lsp_server::ErrorCode;
 use lsp_types::{request, ExecuteCommandParams, MessageType};
-use playground_server::{FrontendMessage, Orwie12Message};
+use playground_server::{FrontendMessage, WebviewRouterMessage};
 use tokio::time::sleep;
 use webbrowser;
 
@@ -37,7 +37,7 @@ impl SyncRequestHandler for ExecuteCommand {
             // Get the actual playground port from session (determined by server after availability check)
             // Fall back to configured port if actual port not set yet
 
-            use playground_server::{FrontendMessage, Orwie12Message};
+            use playground_server::{FrontendMessage, WebviewRouterMessage};
 
             // Construct the URL
             let url = format!("http://localhost:{}", session.playground_port);
@@ -62,8 +62,8 @@ impl SyncRequestHandler for ExecuteCommand {
                 .and_then(|arg| arg.as_str().map(|s| s.to_string()))
             {
                 session
-                    .orwie12_tx
-                    .send(Orwie12Message::FrontendMessage(
+                    .webview_router_input_tx
+                    .send(WebviewRouterMessage::FrontendMessage(
                         FrontendMessage::select_function {
                             // TODO: this can't be correct... but it looks like it is
                             root_path: function_name.to_string(),
@@ -85,8 +85,8 @@ impl SyncRequestHandler for ExecuteCommand {
             }
             Ok(RegisteredCommands::OpenBamlPanel(args)) => {
                 let tx = session
-                    .orwie12_tx
-                    .send(Orwie12Message::FrontendMessage(
+                    .webview_router_input_tx
+                    .send(WebviewRouterMessage::FrontendMessage(
                         FrontendMessage::select_function {
                             // TODO: this can't be correct... but it looks like it is
                             root_path: args.project_id,
@@ -99,8 +99,8 @@ impl SyncRequestHandler for ExecuteCommand {
             }
             Ok(RegisteredCommands::RunTest(args)) => {
                 let tx = session
-                    .orwie12_tx
-                    .send(Orwie12Message::FrontendMessage(
+                    .webview_router_input_tx
+                    .send(WebviewRouterMessage::FrontendMessage(
                         FrontendMessage::run_test {
                             function_name: args.function_name,
                             test_name: args.test_case_name,

engine/language_server/src/server/api/requests/go_to_definition.rs

@@ -4,7 +4,7 @@ use lsp_types::{
     self, request as req, GotoDefinitionParams, GotoDefinitionResponse, Location, Position, Range,
     Url,
 };
-use playground_server::{FrontendMessage, Orwie12Message};
+use playground_server::{FrontendMessage, WebviewRouterMessage};
 
 use crate::{
     baml_project::{position_utils::get_word_at_position, trim_line, BamlRuntimeExt},
@@ -115,8 +115,8 @@ impl SyncRequestHandler for GotoDefinition {
                 {
                     if let Err(e) =
                         session
-                            .orwie12_tx
-                            .send(Orwie12Message::FrontendMessage(
+                            .webview_router_input_tx
+                            .send(WebviewRouterMessage::FrontendMessage(
                                 FrontendMessage::select_function {
                                     root_path: guard.root_path().to_string_lossy().to_string(),
                                     function_name: function.name.clone(),

engine/language_server/src/session.rs

@@ -13,7 +13,7 @@ use index::DocumentController;
 use itertools::any;
 use lsp_types::{ClientCapabilities, TextDocumentContentChangeEvent, Url};
 use parking_lot::Mutex;
-use playground_server::{FrontendMessage, Orwie12Message, Reofji32Message};
+use playground_server::{FrontendMessage, WebviewNotification, WebviewRouterMessage};
 use serde_json::Value;
 
 pub(crate) use self::{capabilities::ResolvedClientCapabilities, settings::AllSettings};
@@ -52,8 +52,8 @@ pub struct Session {
     pub baml_settings: BamlSettings,
 
     pub playground_port: u16,
-    pub orwie12_tx: broadcast::Sender<Orwie12Message>,
-    pub reofji32_tx: broadcast::Sender<Reofji32Message>,
+    pub webview_router_input_tx: broadcast::Sender<WebviewRouterMessage>,
+    pub webview_router_to_websocket_tx: broadcast::Sender<WebviewNotification>,
 }
 
 impl Clone for Session {
@@ -65,8 +65,8 @@ impl Clone for Session {
             resolved_client_capabilities: self.resolved_client_capabilities.clone(),
             baml_settings: self.baml_settings.clone(),
             playground_port: self.playground_port,
-            orwie12_tx: self.orwie12_tx.clone(),
-            reofji32_tx: self.reofji32_tx.clone(),
+            webview_router_input_tx: self.webview_router_input_tx.clone(),
+            webview_router_to_websocket_tx: self.webview_router_to_websocket_tx.clone(),
         }
     }
 }
@@ -78,8 +78,8 @@ impl Session {
         global_settings: ClientSettings,
         workspace_folders: &[(Url, ClientSettings)],
         playground_port: u16,
-        orwie12_tx: broadcast::Sender<Orwie12Message>,
-        reofji32_tx: broadcast::Sender<Reofji32Message>,
+        webview_router_input_tx: broadcast::Sender<WebviewRouterMessage>,
+        webview_router_to_websocket_tx: broadcast::Sender<WebviewNotification>,
         client_version: Option<String>,
     ) -> anyhow::Result<Self> {
         let mut projects = HashMap::new();
@@ -129,8 +129,8 @@ impl Session {
                 baml_settings
             },
             playground_port,
-            orwie12_tx,
-            reofji32_tx,
+            webview_router_input_tx,
+            webview_router_to_websocket_tx,
         })
     }
 
@@ -480,15 +480,15 @@ mod tests {
         let global_settings = ClientSettings::default();
         let workspace_folders = vec![]; // Start with empty workspace
 
-        let (orwie12_tx, _) = broadcast::channel(1);
+        let (webview_router_input_tx, _) = broadcast::channel(1);
 
         Session::new(
             &client_capabilities,
             position_encoding,
             global_settings,
             &workspace_folders,
             0,
-            orwie12_tx,
+            webview_router_input_tx,
             None, // No client_version for this test
         )
         .unwrap()

engine/language_server/src/tests.rs

@@ -127,18 +127,18 @@ pub fn new_test_server(worker_threads: NonZeroUsize) -> anyhow::Result<TestServe
             )
             .unwrap();
 
-        let (orwie12_tx, orwie12_rx) = broadcast::channel(1);
-        let (reofji32_tx, _) = broadcast::channel(1);
+        let (webview_router_input_tx, webview_router_input_rx) = broadcast::channel(1);
+        let (webview_router_to_websocket_tx, _) = broadcast::channel(1);
 
         let server = Server::new_with_connection(
             worker_threads,
             connection,
             init_params,
             ServerArgs {
                 tokio_runtime: tokio::runtime::Runtime::new().unwrap(),
-                reofji32_tx,
-                orwie12_rx,
-                orwie12_tx,
+                webview_router_to_websocket_tx,
+                webview_router_input_rx,
+                webview_router_input_tx,
                 playground_port: 0,
                 proxy_port: 0,
             },