1use crate::development::{
4 DevelopmentError, DevelopmentResult, DiagnosticPosition, LanguageDiagnostic, LanguageResponse,
5 LspClient,
6};
7use serde::{Deserialize, Serialize};
8use serde_json::Value;
9use std::collections::{BTreeMap, VecDeque};
10use std::path::{Path, PathBuf};
11use std::time::Duration;
12
13const EVENT_LIMIT: usize = 512;
14
15#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
16#[serde(rename_all = "camelCase")]
17pub struct LanguageServerConfig {
18 pub command: String,
19 #[serde(default)]
20 pub arguments: Vec<String>,
21}
22
23#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
24#[serde(rename_all = "camelCase")]
25pub struct LanguageServiceEvent {
26 pub sequence: u64,
27 pub server: String,
28 pub actor: String,
29 pub operation: String,
30 pub path: Option<String>,
31 pub result_count: Option<usize>,
32}
33
34pub struct LanguageService {
36 root: PathBuf,
37 servers: BTreeMap<String, LspClient>,
38 events: VecDeque<LanguageServiceEvent>,
39 next_event: u64,
40}
41
42impl LanguageService {
43 pub fn new(root: impl AsRef<Path>) -> DevelopmentResult<Self> {
44 Ok(Self {
45 root: std::fs::canonicalize(root)?,
46 servers: BTreeMap::new(),
47 events: VecDeque::new(),
48 next_event: 1,
49 })
50 }
51
52 pub fn start(&mut self, name: &str, config: &LanguageServerConfig) -> DevelopmentResult<()> {
53 validate_name(name)?;
54 validate_command(config)?;
55 if self.servers.contains_key(name) {
56 return Err(DevelopmentError::Conflict(format!(
57 "language server {name} is already running"
58 )));
59 }
60 let client = LspClient::spawn(&self.root, &config.command, &config.arguments)?;
61 self.servers.insert(name.into(), client);
62 self.record(name, "system", "started", None, None);
63 Ok(())
64 }
65
66 pub fn start_rust_analyzer(&mut self) -> DevelopmentResult<()> {
67 self.start(
68 "rust",
69 &LanguageServerConfig {
70 command: "rust-analyzer".into(),
71 arguments: Vec::new(),
72 },
73 )
74 }
75
76 pub fn stop(&mut self, name: &str) -> DevelopmentResult<()> {
77 self.servers
78 .remove(name)
79 .ok_or_else(|| DevelopmentError::NotFound(format!("language server {name}")))?;
80 self.record(name, "system", "stopped", None, None);
81 Ok(())
82 }
83
84 pub fn names(&self) -> impl Iterator<Item = &str> {
85 self.servers.keys().map(String::as_str)
86 }
87
88 pub fn client_mut(&mut self, name: &str) -> DevelopmentResult<&mut LspClient> {
89 self.servers
90 .get_mut(name)
91 .ok_or_else(|| DevelopmentError::NotFound(format!("language server {name}")))
92 }
93
94 pub fn diagnostics(
95 &mut self,
96 name: &str,
97 actor: &str,
98 path: &str,
99 ) -> DevelopmentResult<Vec<LanguageDiagnostic>> {
100 validate_actor(actor)?;
101 let diagnostics = self.client_mut(name)?.diagnostics(path)?;
102 self.record(
103 name,
104 actor,
105 "diagnostics",
106 Some(path),
107 Some(diagnostics.len()),
108 );
109 Ok(diagnostics)
110 }
111
112 pub fn completion(
113 &mut self,
114 name: &str,
115 actor: &str,
116 path: &str,
117 line: u32,
118 character: u32,
119 ) -> DevelopmentResult<LanguageResponse> {
120 validate_actor(actor)?;
121 let response = self.client_mut(name)?.completion(path, line, character)?;
122 self.record(
123 name,
124 actor,
125 "completion",
126 Some(path),
127 value_count(&response),
128 );
129 Ok(response)
130 }
131
132 pub fn hover(
133 &mut self,
134 name: &str,
135 actor: &str,
136 path: &str,
137 line: u32,
138 character: u32,
139 ) -> DevelopmentResult<LanguageResponse> {
140 validate_actor(actor)?;
141 let response = self.client_mut(name)?.hover(path, line, character)?;
142 self.record(name, actor, "hover", Some(path), value_count(&response));
143 Ok(response)
144 }
145
146 pub fn definition(
147 &mut self,
148 name: &str,
149 actor: &str,
150 path: &str,
151 line: u32,
152 character: u32,
153 ) -> DevelopmentResult<LanguageResponse> {
154 self.position_request(name, actor, "definition", path, |client| {
155 client.definition(path, line, character)
156 })
157 }
158
159 pub fn declaration(
160 &mut self,
161 name: &str,
162 actor: &str,
163 path: &str,
164 line: u32,
165 character: u32,
166 ) -> DevelopmentResult<LanguageResponse> {
167 self.position_request(name, actor, "declaration", path, |client| {
168 client.declaration(path, line, character)
169 })
170 }
171
172 pub fn implementation(
173 &mut self,
174 name: &str,
175 actor: &str,
176 path: &str,
177 line: u32,
178 character: u32,
179 ) -> DevelopmentResult<LanguageResponse> {
180 self.position_request(name, actor, "implementation", path, |client| {
181 client.implementation(path, line, character)
182 })
183 }
184
185 pub fn references(
186 &mut self,
187 name: &str,
188 actor: &str,
189 path: &str,
190 line: u32,
191 character: u32,
192 ) -> DevelopmentResult<LanguageResponse> {
193 self.position_request(name, actor, "references", path, |client| {
194 client.references(path, line, character)
195 })
196 }
197
198 pub fn document_symbols(
199 &mut self,
200 name: &str,
201 actor: &str,
202 path: &str,
203 ) -> DevelopmentResult<LanguageResponse> {
204 self.position_request(name, actor, "documentSymbols", path, |client| {
205 client.document_symbols(path)
206 })
207 }
208
209 pub fn workspace_symbols(
210 &mut self,
211 name: &str,
212 actor: &str,
213 query: &str,
214 ) -> DevelopmentResult<LanguageResponse> {
215 self.position_request(name, actor, "workspaceSymbols", "", |client| {
216 client.workspace_symbols(query)
217 })
218 }
219
220 pub fn inlay_hints(
221 &mut self,
222 name: &str,
223 actor: &str,
224 path: &str,
225 ) -> DevelopmentResult<LanguageResponse> {
226 self.position_request(name, actor, "inlayHints", path, |client| {
227 client.inlay_hints(path)
228 })
229 }
230
231 pub fn signature_help(
232 &mut self,
233 name: &str,
234 actor: &str,
235 path: &str,
236 line: u32,
237 character: u32,
238 ) -> DevelopmentResult<LanguageResponse> {
239 self.position_request(name, actor, "signatureHelp", path, |client| {
240 client.signature_help(path, line, character)
241 })
242 }
243
244 pub fn code_actions(
245 &mut self,
246 name: &str,
247 actor: &str,
248 path: &str,
249 start: DiagnosticPosition,
250 end: DiagnosticPosition,
251 diagnostics: Vec<Value>,
252 ) -> DevelopmentResult<LanguageResponse> {
253 self.position_request(name, actor, "codeActions", path, |client| {
254 client.code_actions(path, start, end, &diagnostics)
255 })
256 }
257
258 pub fn formatting(
259 &mut self,
260 name: &str,
261 actor: &str,
262 path: &str,
263 ) -> DevelopmentResult<LanguageResponse> {
264 self.position_request(name, actor, "formatting", path, |client| {
265 client.formatting(path)
266 })
267 }
268
269 pub fn range_formatting(
270 &mut self,
271 name: &str,
272 actor: &str,
273 path: &str,
274 start: DiagnosticPosition,
275 end: DiagnosticPosition,
276 ) -> DevelopmentResult<LanguageResponse> {
277 self.position_request(name, actor, "rangeFormatting", path, |client| {
278 client.range_formatting(path, start, end)
279 })
280 }
281
282 pub fn semantic_tokens(
283 &mut self,
284 name: &str,
285 actor: &str,
286 path: &str,
287 ) -> DevelopmentResult<LanguageResponse> {
288 self.position_request(name, actor, "semanticTokens", path, |client| {
289 client.semantic_tokens(path)
290 })
291 }
292
293 pub fn rename(
294 &mut self,
295 name: &str,
296 actor: &str,
297 path: &str,
298 line: u32,
299 character: u32,
300 new_name: &str,
301 ) -> DevelopmentResult<LanguageResponse> {
302 self.position_request(name, actor, "rename", path, |client| {
303 client.rename(path, line, character, new_name)
304 })
305 }
306
307 fn position_request(
308 &mut self,
309 name: &str,
310 actor: &str,
311 operation: &str,
312 path: &str,
313 request: impl FnOnce(&mut LspClient) -> DevelopmentResult<LanguageResponse>,
314 ) -> DevelopmentResult<LanguageResponse> {
315 validate_actor(actor)?;
316 let response = request(self.client_mut(name)?)?;
317 self.record(
318 name,
319 actor,
320 operation,
321 (!path.is_empty()).then_some(path),
322 value_count(&response),
323 );
324 Ok(response)
325 }
326
327 pub fn events(&self, since: u64) -> Vec<LanguageServiceEvent> {
328 self.events
329 .iter()
330 .filter(|event| event.sequence > since)
331 .cloned()
332 .collect()
333 }
334
335 pub fn raw_request(
336 &mut self,
337 name: &str,
338 actor: &str,
339 method: &str,
340 params: Value,
341 timeout: Duration,
342 ) -> DevelopmentResult<LanguageResponse> {
343 validate_actor(actor)?;
344 let response = self
345 .client_mut(name)?
346 .raw_request(method, params, timeout)?;
347 self.record(name, actor, method, None, value_count(&response));
348 Ok(response)
349 }
350
351 fn record(
352 &mut self,
353 server: &str,
354 actor: &str,
355 operation: &str,
356 path: Option<&str>,
357 result_count: Option<usize>,
358 ) {
359 if self.events.len() == EVENT_LIMIT {
360 self.events.pop_front();
361 }
362 self.events.push_back(LanguageServiceEvent {
363 sequence: self.next_event,
364 server: server.into(),
365 actor: actor.into(),
366 operation: operation.into(),
367 path: path.map(str::to_string),
368 result_count,
369 });
370 self.next_event = self.next_event.saturating_add(1);
371 }
372}
373
374fn value_count(response: &LanguageResponse) -> Option<usize> {
375 response
376 .result
377 .as_array()
378 .map(Vec::len)
379 .or_else(|| response.result.as_object().map(serde_json::Map::len))
380}
381
382fn validate_name(name: &str) -> DevelopmentResult<()> {
383 if name.is_empty()
384 || name.len() > 64
385 || !name
386 .chars()
387 .all(|character| character.is_ascii_alphanumeric() || "-_".contains(character))
388 {
389 return Err(DevelopmentError::InvalidInput(
390 "language server names must be 1..=64 ASCII letters, digits, '-' or '_'".into(),
391 ));
392 }
393 Ok(())
394}
395
396fn validate_actor(actor: &str) -> DevelopmentResult<()> {
397 if actor.is_empty() || actor.len() > 256 || actor.chars().any(char::is_control) {
398 return Err(DevelopmentError::InvalidInput(
399 "language-service actor must contain 1..=256 non-control bytes".into(),
400 ));
401 }
402 Ok(())
403}
404
405fn validate_command(config: &LanguageServerConfig) -> DevelopmentResult<()> {
406 if config.command.is_empty()
407 || config.command.len() > 4096
408 || config.command.chars().any(char::is_control)
409 || config.arguments.len() > 64
410 || config.arguments.iter().any(|argument| {
411 argument.len() > 4096 || argument.chars().any(|character| character == '\0')
412 })
413 {
414 return Err(DevelopmentError::InvalidInput(
415 "language server command or arguments are invalid".into(),
416 ));
417 }
418 Ok(())
419}
420
421#[cfg(test)]
422mod tests {
423 use super::*;
424 use std::process::Command;
425 use std::sync::atomic::{AtomicU64, Ordering};
426
427 static NEXT_ROOT: AtomicU64 = AtomicU64::new(0);
428
429 #[test]
430 fn language_service_configuration_fails_closed() {
431 assert!(validate_name("rust").is_ok());
432 assert!(validate_name("../rust").is_err());
433 assert!(
434 validate_command(&LanguageServerConfig {
435 command: "rust-analyzer".into(),
436 arguments: Vec::new()
437 })
438 .is_ok()
439 );
440 assert!(validate_actor("embedded-agent-1").is_ok());
441 assert!(validate_actor("bad\nactor").is_err());
442 }
443
444 #[test]
445 fn shared_rust_language_service_serves_multiple_actors() {
446 if !Command::new("rust-analyzer")
447 .arg("--version")
448 .output()
449 .is_ok_and(|output| output.status.success())
450 {
451 return;
452 }
453 let sequence = NEXT_ROOT.fetch_add(1, Ordering::Relaxed);
454 let root = std::env::temp_dir().join(format!(
455 "glass-shared-lsp-{}-{sequence}",
456 std::process::id()
457 ));
458 std::fs::create_dir_all(root.join("src")).unwrap();
459 std::fs::write(
460 root.join("Cargo.toml"),
461 "[package]\nname='shared_lsp_fixture'\nversion='0.1.0'\nedition='2024'\n",
462 )
463 .unwrap();
464 std::fs::write(
465 root.join("src/lib.rs"),
466 "pub fn value() -> u32 { 42 }\npub fn use_value() { val }\n",
467 )
468 .unwrap();
469 let mut service = LanguageService::new(&root).unwrap();
470 service.start_rust_analyzer().unwrap();
471 let response = service
472 .completion("rust", "human", "src/lib.rs", 2, 25)
473 .unwrap();
474 assert_eq!(response.method, "textDocument/completion");
475 let hover = service
476 .hover("rust", "embedded-agent", "src/lib.rs", 1, 8)
477 .unwrap();
478 assert_eq!(hover.method, "textDocument/hover");
479 assert_eq!(service.names().collect::<Vec<_>>(), vec!["rust"]);
480 assert_eq!(service.events(0).len(), 3);
481 service.stop("rust").unwrap();
482 drop(service);
483 std::fs::remove_dir_all(root).unwrap();
484 }
485}