Function lsp_worker

src/lsp/mod.rs:95–153

(
    server: &str,
    tx: mpsc::Sender<LspMessage>,
    req_rx: &mut mpsc::Receiver<String>,
)

}

async fn lsp_worker(
    server: &str,
    tx: mpsc::Sender<LspMessage>,
    req_rx: &mut mpsc::Receiver<String>,
) -> Result<()> {
    let mut child: Child = Command::new(server)
        .arg("--stdio")
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::null())
        .spawn()
        .with_context(|| format!("Failed to start LSP: {server}"))?;

    let stdin: ChildStdin = child.stdin.take().context("stdin unavailable")?;
    let stdout: ChildStdout = child.stdout.take().context("stdout unavailable")?;

    let init_req = json_rpc_request(1, "initialize", json!({
        "processId": std::process::id(),
        "rootUri": null,
        "capabilities": {}
    }));

    let mut stdin = tokio::io::BufWriter::new(stdin);
    send_rpc(&mut stdin, &init_req).await?;

    let mut reader = BufReader::new(stdout);
    let mut initialized = false;
    let mut pending: Vec<String> = Vec::new();

    loop {
        tokio::select! {
            msg = read_message(&mut reader) => {
                match msg {
                    Ok(body) => {
                        if handle_lsp_response(&body, &tx).await && !initialized {
                            initialized = true;
                            let initialized_msg = json_rpc_notification("initialized", json!({}));
                            send_rpc(&mut stdin, &initialized_msg).await?;
                            for msg in pending.drain(..) {
                                send_rpc(&mut stdin, &msg).await?;
                            }
                            let _ = tx.send(LspMessage::Ready { server: server.to_string() }).await;
                        }
                    }
                    Err(_) => break,
                }
            }
            req = req_rx.recv() => {
                match req {
                    Some(msg) if initialized => { let _ = send_rpc(&mut stdin, &msg).await; }
                    Some(msg) => pending.push(msg),
                    None => break,
                }
            }
        }
    }

    Ok(())