//! LSP(stdio)処理(T026/T029/T034)。
//! 参照: contracts/zed-ide-bridge.md
//!
//! Zed はこのプロセスを language server として起動する。ここでは:
//! - initialize: capabilities 応答 + initializationOptions(portRange)を main へ通知
//! - didOpen/didChange: アクティブファイル(FR-020)
//! - documentHighlight: カーソル位置(FR-021, デバウンス)
//! - codeAction: 選択範囲(FR-021, 副作用依存・デバウンス)
//! - inlayHint/documentSymbol/documentColor/foldingRange/codeLens:
//! タブ切替の捕捉(FR-030, レンダリング駆動シグナル・デバウンス)
//! を捕捉し、SharedState を更新する(更新時に push 配信される)。
//!
//! untitled/未保存/対象外ファイルは安全に無視(FR-023, エラーにしない)。
use crate::notify::LspOut;
use crate::protocol::{rpc_result, RpcMessage};
use crate::state::{EditorContext, Position, Selection, SharedState};
use anyhow::Result;
use serde_json::{json, Value};
use std::sync::Arc;
use std::time::Duration;
use tokio::io::{AsyncRead, AsyncReadExt, AsyncWriteExt};
use tokio::sync::mpsc;
use tokio::sync::oneshot;
/// initialize 受信時に main へ渡す情報。
pub struct InitInfo {
pub port_min: u16,
pub port_max: u16,
}
/// LSP メインループ。stdin を読み、Content-Length フレームを解釈して dispatch する。
pub async fn run<R>(
mut reader: R,
out: LspOut,
state: Arc<SharedState>,
// initialize を受け取ったら一度だけ送る(WS サーバ起動のトリガ)。
init_tx: oneshot::Sender<InitInfo>,
) -> Result<()>
where
R: AsyncRead + Unpin,
{
let mut init_tx = Some(init_tx);
// codeAction/documentHighlight はデバウンスする(FR-025)。
let (debounce_tx, debounce_rx) = mpsc::unbounded_channel::<EditorContext>();
spawn_debouncer(debounce_rx, state.clone(), Duration::from_millis(80));
// 開いているドキュメントの本文(uri -> text)。選択テキスト抽出に使う。
let mut docs: std::collections::HashMap<String, String> = std::collections::HashMap::new();
let mut buf: Vec<u8> = Vec::new();
let mut chunk = [0u8; 8192];
loop {
// 既存バッファから 1 メッセージを取り出せるか試す。
while let Some((headers_end, content_len)) = peek_frame(&buf) {
let total = headers_end + content_len;
if buf.len() < total {
break; // body 未到着
}
let body = buf[headers_end..total].to_vec();
buf.drain(0..total);
if let Ok(msg) = serde_json::from_slice::<RpcMessage>(&body) {
handle_message(msg, &out, &state, &debounce_tx, &mut init_tx, &mut docs).await;
}
}
let n = reader.read(&mut chunk).await?;
if n == 0 {
break; // EOF(Zed 終了)
}
buf.extend_from_slice(&chunk[..n]);
}
Ok(())
}
/// バッファ先頭の `Content-Length` ヘッダを解析し、(ヘッダ終端, 本文長) を返す。
fn peek_frame(buf: &[u8]) -> Option<(usize, usize)> {
let sep = b"\r\n\r\n";
let pos = buf.windows(4).position(|w| w == sep)?;
let headers = std::str::from_utf8(&buf[..pos]).ok()?;
let mut len = None;
for line in headers.split("\r\n") {
if let Some(v) = line.strip_prefix("Content-Length:") {
len = v.trim().parse::<usize>().ok();
}
}
Some((pos + 4, len?))
}
async fn handle_message(
msg: RpcMessage,
out: &LspOut,
state: &Arc<SharedState>,
debounce_tx: &mpsc::UnboundedSender<EditorContext>,
init_tx: &mut Option<oneshot::Sender<InitInfo>>,
docs: &mut std::collections::HashMap<String, String>,
) {
let method = match &msg.method {
Some(m) => m.as_str(),
None => return, // レスポンスは無視
};
trace_log(
"recv",
method,
extract_uri(msg.params.as_ref()).as_deref().unwrap_or(""),
);
match method {
"initialize" => {
// initializationOptions から portRange を読む。
let (min, max) = parse_port_range(msg.params.as_ref());
if let Some(tx) = init_tx.take() {
let _ = tx.send(InitInfo {
port_min: min,
port_max: max,
});
}
if let Some(id) = msg.id {
let _ = out.send(rpc_result(id, server_capabilities()));
}
}
"initialized" | "$/setTrace" => { /* 通知: 何もしない */ }
"shutdown" => {
if let Some(id) = msg.id {
let _ = out.send(rpc_result(id, Value::Null));
}
}
"exit" => {
std::process::exit(0);
}
"textDocument/didOpen" | "textDocument/didChange" => {
// アクティブファイルを更新(FR-020)。本文も保持(選択テキスト抽出用)。
if let Some(uri) = extract_uri(msg.params.as_ref()) {
if let Some(text) = extract_document_text(msg.params.as_ref()) {
docs.insert(uri.clone(), text);
}
update_active_file(state, &uri).await;
}
}
"textDocument/documentHighlight" => {
// カーソル位置を選択(空)として捕捉(FR-021)。text は ""。
if let (Some(uri), Some(pos)) = (
extract_text_document_uri(msg.params.as_ref()),
extract_position(msg.params.as_ref()),
) {
let ctx = build_ctx(
&uri,
Selection {
start: pos.clone(),
end: pos,
is_empty: true,
},
String::new(),
);
let _ = debounce_tx.send(ctx);
}
// documentHighlight には結果(ハイライト範囲)を返す必要があるが、
// 本ブリッジは副作用(位置取得)目的なので空配列で良い。
if let Some(id) = msg.id {
let _ = out.send(rpc_result(id, json!([])));
}
}
"textDocument/codeAction" => {
// codeAction の range を選択範囲として捕捉(FR-021, 副作用依存)。
// 保持中の本文から選択テキストを抽出して text に載せる。
if let (Some(uri), Some(sel)) = (
extract_text_document_uri(msg.params.as_ref()),
extract_range_as_selection(msg.params.as_ref()),
) {
let text = if sel.is_empty {
String::new()
} else {
docs.get(&uri)
.map(|content| extract_range_text(content, &sel))
.unwrap_or_default()
};
let ctx = build_ctx(&uri, sel, text);
let _ = debounce_tx.send(ctx);
}
if let Some(id) = msg.id {
let _ = out.send(rpc_result(id, json!([])));
}
}
// FR-030: タブ切替の捕捉。Zed はタブ切替(アクティブエディタ変更)単体では
// 編集系シグナル(didChange/documentHighlight 等)を発火しないが、
// 「可視になったバッファ」へのレンダリング駆動リクエストは発行する。
// これを契機に URI がアクティブファイルと異なればタブ切替とみなして push する。
// エディタ操作起因のイベント駆動であり、FR-027 のハートビート禁止に該当しない。
"textDocument/inlayHint"
| "textDocument/documentSymbol"
| "textDocument/documentColor"
| "textDocument/foldingRange"
| "textDocument/codeLens" => {
if let Some(uri) = extract_text_document_uri(msg.params.as_ref()) {
maybe_switch_active_file(state, debounce_tx, &uri).await;
}
// いずれも空配列が妥当な応答(本ブリッジは副作用目的)。
if let Some(id) = msg.id {
let _ = out.send(rpc_result(id, json!([])));
}
}
_ => {
// 未知のリクエストには空応答(Zed を待たせない)。
if let Some(id) = msg.id {
let _ = out.send(rpc_result(id, Value::Null));
}
}
}
}
/// FR-030: レンダリング駆動リクエストの URI が現在のアクティブファイルと異なれば
/// タブ切替とみなし、カーソル未知(0:0, isEmpty=true, text="")で切り替えを push する。
/// 同一ファイルへの再リクエスト(スクロール・編集等)では既存の選択を上書きしない。
async fn maybe_switch_active_file(
state: &Arc<SharedState>,
debounce_tx: &mpsc::UnboundedSender<EditorContext>,
uri: &str,
) {
let cur = state.snapshot().await;
if cur.file_url.as_deref() == Some(uri) {
return;
}
trace_log("switch", "active_file", uri);
let ctx = build_ctx(
uri,
Selection {
start: Position::default(),
end: Position::default(),
is_empty: true,
},
String::new(),
);
let _ = debounce_tx.send(ctx);
}
/// トレースログ(実機検証用, FR-030 の research 補助)。
/// `CC_IDE_TRACE=<path>` か、`~/.cache/cc-ide/trace.on` が存在するとき
/// `~/.cache/cc-ide/trace.log` へ追記する。通常運用ではゼロコスト(初回判定のみ)。
fn trace_log(tag: &str, a: &str, b: &str) {
static PATH: std::sync::OnceLock<Option<std::path::PathBuf>> = std::sync::OnceLock::new();
let path = PATH.get_or_init(|| {
if let Ok(p) = std::env::var("CC_IDE_TRACE") {
return Some(std::path::PathBuf::from(p));
}
let home = std::env::var("HOME").ok()?;
let dir = std::path::Path::new(&home).join(".cache").join("cc-ide");
dir.join("trace.on").exists().then(|| dir.join("trace.log"))
});
if let Some(p) = path {
use std::io::Write;
if let Ok(mut f) = std::fs::OpenOptions::new()
.create(true)
.append(true)
.open(p)
{
let _ = writeln!(f, "{tag}\t{a}\t{b}");
}
}
}
/// アクティブファイルのみ更新(選択は維持)。untitled は安全に無視(FR-023)。
async fn update_active_file(state: &Arc<SharedState>, uri: &str) {
let mut ctx = state.snapshot().await;
apply_uri(&mut ctx, uri);
state.update(ctx).await;
}
/// uri + 選択 + 選択テキストから完全な EditorContext を作る。
fn build_ctx(uri: &str, sel: Selection, text: String) -> EditorContext {
let mut ctx = EditorContext {
selection: Some(sel),
text,
..Default::default()
};
apply_uri(&mut ctx, uri);
ctx
}
/// didOpen / didChange のパラメータから本文テキストを取り出す。
/// didOpen: params.textDocument.text、didChange(Full): params.contentChanges[last].text。
fn extract_document_text(params: Option<&Value>) -> Option<String> {
let p = params?;
if let Some(t) = p
.get("textDocument")
.and_then(|d| d.get("text"))
.and_then(|v| v.as_str())
{
return Some(t.to_string());
}
// contentChanges は配列。Full 同期では最後の要素の text が全文。
let changes = p.get("contentChanges")?.as_array()?;
let last = changes.last()?;
last.get("text")
.and_then(|v| v.as_str())
.map(|s| s.to_string())
}
/// 本文と選択範囲(0-origin の line/character)から選択テキストを切り出す。
/// LSP の character は UTF-16 単位だが、実用上 char 単位で近似する。
fn extract_range_text(content: &str, sel: &Selection) -> String {
let lines: Vec<&str> = content.split('\n').collect();
let (s, e) = (&sel.start, &sel.end);
let (sl, el) = (s.line as usize, e.line as usize);
if sl >= lines.len() {
return String::new();
}
if sl == el {
let chars: Vec<char> = lines[sl].chars().collect();
let sc = (s.character as usize).min(chars.len());
let ec = (e.character as usize).min(chars.len()).max(sc);
return chars[sc..ec].iter().collect();
}
let mut out = String::new();
#[allow(clippy::needless_range_loop)]
for ln in sl..=el.min(lines.len().saturating_sub(1)) {
let chars: Vec<char> = lines[ln].chars().collect();
if ln == sl {
let sc = (s.character as usize).min(chars.len());
out.extend(&chars[sc..]);
out.push('\n');
} else if ln == el {
let ec = (e.character as usize).min(chars.len());
out.extend(&chars[..ec]);
} else {
out.push_str(lines[ln]);
out.push('\n');
}
}
out
}
/// file:// URI を filePath/fileUrl へ反映。非 file スキーム(untitled 等)は filePath 無しで安全に扱う。
fn apply_uri(ctx: &mut EditorContext, uri: &str) {
if let Some(path) = uri.strip_prefix("file://") {
ctx.file_path = Some(percent_decode(path));
ctx.file_url = Some(uri.to_string());
} else {
// untitled:... など → アドレス不可だがエラーにしない(FR-023)。
ctx.file_path = None;
ctx.file_url = Some(uri.to_string());
}
}
/// %XX をバイト単位でデコードして UTF-8 文字列へ復元する(日本語パス等のため)。
/// 不正な %XX(16進2桁が続かない)はそのまま残し、不正 UTF-8 は U+FFFD に置換する。
fn percent_decode(input: &str) -> String {
let bytes = input.as_bytes();
let mut out: Vec<u8> = Vec::with_capacity(bytes.len());
let mut i = 0;
while i < bytes.len() {
if bytes[i] == b'%' && i + 2 < bytes.len() {
let hi = (bytes[i + 1] as char).to_digit(16);
let lo = (bytes[i + 2] as char).to_digit(16);
if let (Some(hi), Some(lo)) = (hi, lo) {
out.push((hi * 16 + lo) as u8);
i += 3;
continue;
}
}
out.push(bytes[i]);
i += 1;
}
String::from_utf8_lossy(&out).into_owned()
}
/// デバウンサ: 短時間に連続する更新を間引いて最後の1件のみ反映(FR-025)。
fn spawn_debouncer(
mut rx: mpsc::UnboundedReceiver<EditorContext>,
state: Arc<SharedState>,
window: Duration,
) {
tokio::spawn(async move {
let mut pending: Option<EditorContext> = None;
loop {
tokio::select! {
maybe = rx.recv() => {
match maybe {
Some(ctx) => { pending = Some(ctx); }
None => break, // チャネル閉鎖
}
}
_ = tokio::time::sleep(window), if pending.is_some() => {
if let Some(ctx) = pending.take() {
state.update(ctx).await;
}
}
}
}
});
}
fn server_capabilities() -> Value {
json!({
"capabilities": {
"textDocumentSync": 1, // Full
"documentHighlightProvider": true,
"codeActionProvider": true,
"selectionRangeProvider": true,
// FR-030: タブ切替捕捉用のレンダリング駆動シグナル群。
// Zed が可視バッファへ発行するリクエストを受けるために宣言する
// (応答は常に空。どれが実際に発火するかは Zed の設定・版に依存)。
"documentSymbolProvider": true,
"inlayHintProvider": true,
"colorProvider": true,
"foldingRangeProvider": true,
"codeLensProvider": { "resolveProvider": false }
},
"serverInfo": { "name": "cc-ide-server", "version": env!("CARGO_PKG_VERSION") }
})
}
// ---- params 抽出ヘルパ ----
fn parse_port_range(params: Option<&Value>) -> (u16, u16) {
let default = (10000u16, 65535u16);
let opts = match params.and_then(|p| p.get("initializationOptions")) {
Some(o) => o,
None => return default,
};
let min = opts
.get("portRange")
.and_then(|r| r.get("min"))
.and_then(|v| v.as_u64())
.map(|v| v as u16)
.unwrap_or(default.0);
let max = opts
.get("portRange")
.and_then(|r| r.get("max"))
.and_then(|v| v.as_u64())
.map(|v| v as u16)
.unwrap_or(default.1);
(min, max)
}
fn extract_uri(params: Option<&Value>) -> Option<String> {
params?
.get("textDocument")?
.get("uri")?
.as_str()
.map(|s| s.to_string())
}
fn extract_text_document_uri(params: Option<&Value>) -> Option<String> {
extract_uri(params)
}
fn extract_position(params: Option<&Value>) -> Option<Position> {
let p = params?.get("position")?;
Some(Position {
line: p.get("line")?.as_u64()? as u32,
character: p.get("character")?.as_u64()? as u32,
})
}
fn extract_range_as_selection(params: Option<&Value>) -> Option<Selection> {
let r = params?.get("range")?;
let start = r.get("start")?;
let end = r.get("end")?;
let s = Position {
line: start.get("line")?.as_u64()? as u32,
character: start.get("character")?.as_u64()? as u32,
};
let e = Position {
line: end.get("line")?.as_u64()? as u32,
character: end.get("character")?.as_u64()? as u32,
};
let is_empty = s == e;
Some(Selection {
start: s,
end: e,
is_empty,
})
}
/// LSP stdout への writer タスク。Content-Length フレームに包んで書き出す。
pub async fn writer_task<W>(mut w: W, mut rx: mpsc::UnboundedReceiver<Value>) -> Result<()>
where
W: AsyncWriteExt + Unpin,
{
while let Some(msg) = rx.recv().await {
let body = serde_json::to_vec(&msg)?;
let header = format!("Content-Length: {}\r\n\r\n", body.len());
w.write_all(header.as_bytes()).await?;
w.write_all(&body).await?;
w.flush().await?;
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
// T024: documentHighlight の position → cursor 変換。
#[test]
fn position_extraction() {
let params = json!({
"textDocument": { "uri": "file:///a/b.rs" },
"position": { "line": 12, "character": 4 }
});
let pos = extract_position(Some(¶ms)).expect("position");
assert_eq!(pos.line, 12);
assert_eq!(pos.character, 4);
}
// T024: codeAction の range → selection 変換(非空)。
#[test]
fn range_extraction_nonempty() {
let params = json!({
"textDocument": { "uri": "file:///a/b.rs" },
"range": {
"start": { "line": 1, "character": 0 },
"end": { "line": 3, "character": 7 }
}
});
let sel = extract_range_as_selection(Some(¶ms)).expect("selection");
assert_eq!(sel.start.line, 1);
assert_eq!(sel.end.line, 3);
assert!(!sel.is_empty);
}
// start==end のときは isEmpty=true(カーソルのみ)。
#[test]
fn range_extraction_empty() {
let params = json!({
"range": {
"start": { "line": 5, "character": 2 },
"end": { "line": 5, "character": 2 }
}
});
let sel = extract_range_as_selection(Some(¶ms)).expect("selection");
assert!(sel.is_empty);
}
// file:// URI は filePath/fileUrl へ、untitled は filePath 無しで安全に(FR-023)。
#[test]
fn uri_apply_file_and_untitled() {
let mut ctx = EditorContext::default();
apply_uri(&mut ctx, "file:///Users/x/main.rs");
assert_eq!(ctx.file_path.as_deref(), Some("/Users/x/main.rs"));
let mut ctx2 = EditorContext::default();
apply_uri(&mut ctx2, "untitled:Untitled-1");
assert!(ctx2.file_path.is_none()); // エラーにせず None
}
// パーセントデコード: 日本語などマルチバイト文字を含むパスを復元する。
#[test]
fn uri_apply_percent_decodes_multibyte() {
let mut ctx = EditorContext::default();
apply_uri(
&mut ctx,
"file:///Users/x/ws/Go%E8%A8%80%E8%AA%9E%E5%AD%A6%E7%BF%92/2026-07-07%20Rails%E3%81%A8Go.md",
);
assert_eq!(
ctx.file_path.as_deref(),
Some("/Users/x/ws/Go言語学習/2026-07-07 RailsとGo.md")
);
// fileUrl はエンコードされた元の URI のまま保持する
assert!(ctx.file_url.as_deref().unwrap().contains("%E8%A8%80"));
}
// percent_decode の境界: 不正な %XX はそのまま、% 直後の生マルチバイトで panic しない。
#[test]
fn percent_decode_edge_cases() {
assert_eq!(percent_decode("a%2Gb"), "a%2Gb"); // 16進でない → そのまま
assert_eq!(percent_decode("100%"), "100%"); // 末尾の % 単独
assert_eq!(percent_decode("%あ"), "%あ"); // % 直後にマルチバイト → panic しない
assert_eq!(percent_decode("%41%20%42"), "A B");
}
// 選択テキスト抽出(単一行・複数行)。
#[test]
fn range_text_single_and_multiline() {
let content = "abcdef\nghijkl\nmnopqr";
// 単一行: line0 char1..4 -> "bcd"
let s = Selection {
start: Position {
line: 0,
character: 1,
},
end: Position {
line: 0,
character: 4,
},
is_empty: false,
};
assert_eq!(extract_range_text(content, &s), "bcd");
// 複数行: line0 char2 .. line2 char3 -> "cdef\nghijkl\nmno"
let m = Selection {
start: Position {
line: 0,
character: 2,
},
end: Position {
line: 2,
character: 3,
},
is_empty: false,
};
assert_eq!(extract_range_text(content, &m), "cdef\nghijkl\nmno");
}
// didOpen/didChange からの本文抽出。
#[test]
fn document_text_extraction() {
let open = json!({"textDocument": {"uri":"file:///a","text":"hello"}});
assert_eq!(extract_document_text(Some(&open)).as_deref(), Some("hello"));
let change = json!({"contentChanges": [{"text":"world"}]});
assert_eq!(
extract_document_text(Some(&change)).as_deref(),
Some("world")
);
}
// FR-030: レンダリング駆動リクエスト(inlayHint 等)で URI が変われば
// タブ切替として空選択のコンテキストがデバウンサへ送られる。
#[tokio::test]
async fn tab_switch_via_render_request() {
let state = SharedState::new();
// 現在のアクティブファイルは A。
state
.update(EditorContext {
file_path: Some("/a.rs".into()),
file_url: Some("file:///a.rs".into()),
selection: None,
text: String::new(),
})
.await;
let (out_tx, _out_rx) = mpsc::unbounded_channel::<Value>();
let (dbg_tx, mut dbg_rx) = mpsc::unbounded_channel::<EditorContext>();
let mut init_tx: Option<oneshot::Sender<InitInfo>> = None;
let mut docs = std::collections::HashMap::new();
// B への inlayHint リクエスト → タブ切替として検知。
let msg = RpcMessage {
jsonrpc: Some("2.0".into()),
id: Some(json!(7)),
method: Some("textDocument/inlayHint".into()),
params: Some(json!({ "textDocument": { "uri": "file:///b.rs" } })),
};
handle_message(msg, &out_tx, &state, &dbg_tx, &mut init_tx, &mut docs).await;
let ctx = dbg_rx.try_recv().expect("switch push");
assert_eq!(ctx.file_path.as_deref(), Some("/b.rs"));
let sel = ctx.selection.expect("selection");
assert!(sel.is_empty, "カーソル未知なので isEmpty");
assert_eq!(ctx.text, "");
}
// FR-030: 同一ファイルへの再リクエスト(スクロール等)では push しない
// (codeAction で得た選択を空選択で上書きしないため)。
#[tokio::test]
async fn same_file_render_request_is_noop() {
let state = SharedState::new();
state
.update(EditorContext {
file_path: Some("/a.rs".into()),
file_url: Some("file:///a.rs".into()),
selection: Some(Selection {
start: Position {
line: 1,
character: 2,
},
end: Position {
line: 3,
character: 4,
},
is_empty: false,
}),
text: "sel".into(),
})
.await;
let (out_tx, _out_rx) = mpsc::unbounded_channel::<Value>();
let (dbg_tx, mut dbg_rx) = mpsc::unbounded_channel::<EditorContext>();
let mut init_tx: Option<oneshot::Sender<InitInfo>> = None;
let mut docs = std::collections::HashMap::new();
let msg = RpcMessage {
jsonrpc: Some("2.0".into()),
id: Some(json!(8)),
method: Some("textDocument/documentSymbol".into()),
params: Some(json!({ "textDocument": { "uri": "file:///a.rs" } })),
};
handle_message(msg, &out_tx, &state, &dbg_tx, &mut init_tx, &mut docs).await;
assert!(dbg_rx.try_recv().is_err(), "同一ファイルでは push しない");
// 状態も不変(選択を保持)。
let cur = state.snapshot().await;
assert_eq!(cur.text, "sel");
}
// FR-030: capabilities にレンダリング駆動シグナル群が宣言されている。
#[test]
fn render_signal_capabilities_declared() {
let caps = server_capabilities();
let c = &caps["capabilities"];
assert_eq!(c["documentSymbolProvider"], json!(true));
assert_eq!(c["inlayHintProvider"], json!(true));
assert_eq!(c["colorProvider"], json!(true));
assert_eq!(c["foldingRangeProvider"], json!(true));
assert_eq!(c["codeLensProvider"]["resolveProvider"], json!(false));
}
// portRange の解析(initializationOptions)。
#[test]
fn port_range_parsing() {
let params = json!({
"initializationOptions": { "portRange": { "min": 20000, "max": 20100 } }
});
let (min, max) = parse_port_range(Some(¶ms));
assert_eq!((min, max), (20000, 20100));
// 欠落時は既定。
let (dmin, dmax) = parse_port_range(None);
assert_eq!((dmin, dmax), (10000, 65535));
}
}