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 signature_help(
221 &mut self,
222 name: &str,
223 actor: &str,
224 path: &str,
225 line: u32,
226 character: u32,
227 ) -> DevelopmentResult<LanguageResponse> {
228 self.position_request(name, actor, "signatureHelp", path, |client| {
229 client.signature_help(path, line, character)
230 })
231 }
232
233 pub fn code_actions(
234 &mut self,
235 name: &str,
236 actor: &str,
237 path: &str,
238 start: DiagnosticPosition,
239 end: DiagnosticPosition,
240 diagnostics: Vec<Value>,
241 ) -> DevelopmentResult<LanguageResponse> {
242 self.position_request(name, actor, "codeActions", path, |client| {
243 client.code_actions(path, start, end, &diagnostics)
244 })
245 }
246
247 pub fn formatting(
248 &mut self,
249 name: &str,
250 actor: &str,
251 path: &str,
252 ) -> DevelopmentResult<LanguageResponse> {
253 self.position_request(name, actor, "formatting", path, |client| {
254 client.formatting(path)
255 })
256 }
257
258 pub fn range_formatting(
259 &mut self,
260 name: &str,
261 actor: &str,
262 path: &str,
263 start: DiagnosticPosition,
264 end: DiagnosticPosition,
265 ) -> DevelopmentResult<LanguageResponse> {
266 self.position_request(name, actor, "rangeFormatting", path, |client| {
267 client.range_formatting(path, start, end)
268 })
269 }
270
271 pub fn semantic_tokens(
272 &mut self,
273 name: &str,
274 actor: &str,
275 path: &str,
276 ) -> DevelopmentResult<LanguageResponse> {
277 self.position_request(name, actor, "semanticTokens", path, |client| {
278 client.semantic_tokens(path)
279 })
280 }
281
282 pub fn rename(
283 &mut self,
284 name: &str,
285 actor: &str,
286 path: &str,
287 line: u32,
288 character: u32,
289 new_name: &str,
290 ) -> DevelopmentResult<LanguageResponse> {
291 self.position_request(name, actor, "rename", path, |client| {
292 client.rename(path, line, character, new_name)
293 })
294 }
295
296 fn position_request(
297 &mut self,
298 name: &str,
299 actor: &str,
300 operation: &str,
301 path: &str,
302 request: impl FnOnce(&mut LspClient) -> DevelopmentResult<LanguageResponse>,
303 ) -> DevelopmentResult<LanguageResponse> {
304 validate_actor(actor)?;
305 let response = request(self.client_mut(name)?)?;
306 self.record(
307 name,
308 actor,
309 operation,
310 (!path.is_empty()).then_some(path),
311 value_count(&response),
312 );
313 Ok(response)
314 }
315
316 pub fn events(&self, since: u64) -> Vec<LanguageServiceEvent> {
317 self.events
318 .iter()
319 .filter(|event| event.sequence > since)
320 .cloned()
321 .collect()
322 }
323
324 pub fn raw_request(
325 &mut self,
326 name: &str,
327 actor: &str,
328 method: &str,
329 params: Value,
330 timeout: Duration,
331 ) -> DevelopmentResult<LanguageResponse> {
332 validate_actor(actor)?;
333 let response = self
334 .client_mut(name)?
335 .raw_request(method, params, timeout)?;
336 self.record(name, actor, method, None, value_count(&response));
337 Ok(response)
338 }
339
340 fn record(
341 &mut self,
342 server: &str,
343 actor: &str,
344 operation: &str,
345 path: Option<&str>,
346 result_count: Option<usize>,
347 ) {
348 if self.events.len() == EVENT_LIMIT {
349 self.events.pop_front();
350 }
351 self.events.push_back(LanguageServiceEvent {
352 sequence: self.next_event,
353 server: server.into(),
354 actor: actor.into(),
355 operation: operation.into(),
356 path: path.map(str::to_string),
357 result_count,
358 });
359 self.next_event = self.next_event.saturating_add(1);
360 }
361}
362
363fn value_count(response: &LanguageResponse) -> Option<usize> {
364 response
365 .result
366 .as_array()
367 .map(Vec::len)
368 .or_else(|| response.result.as_object().map(serde_json::Map::len))
369}
370
371fn validate_name(name: &str) -> DevelopmentResult<()> {
372 if name.is_empty()
373 || name.len() > 64
374 || !name
375 .chars()
376 .all(|character| character.is_ascii_alphanumeric() || "-_".contains(character))
377 {
378 return Err(DevelopmentError::InvalidInput(
379 "language server names must be 1..=64 ASCII letters, digits, '-' or '_'".into(),
380 ));
381 }
382 Ok(())
383}
384
385fn validate_actor(actor: &str) -> DevelopmentResult<()> {
386 if actor.is_empty() || actor.len() > 256 || actor.chars().any(char::is_control) {
387 return Err(DevelopmentError::InvalidInput(
388 "language-service actor must contain 1..=256 non-control bytes".into(),
389 ));
390 }
391 Ok(())
392}
393
394fn validate_command(config: &LanguageServerConfig) -> DevelopmentResult<()> {
395 if config.command.is_empty()
396 || config.command.len() > 4096
397 || config.command.chars().any(char::is_control)
398 || config.arguments.len() > 64
399 || config.arguments.iter().any(|argument| {
400 argument.len() > 4096 || argument.chars().any(|character| character == '\0')
401 })
402 {
403 return Err(DevelopmentError::InvalidInput(
404 "language server command or arguments are invalid".into(),
405 ));
406 }
407 Ok(())
408}
409
410#[cfg(test)]
411mod tests {
412 use super::*;
413 use std::process::Command;
414 use std::sync::atomic::{AtomicU64, Ordering};
415
416 static NEXT_ROOT: AtomicU64 = AtomicU64::new(0);
417
418 #[test]
419 fn language_service_configuration_fails_closed() {
420 assert!(validate_name("rust").is_ok());
421 assert!(validate_name("../rust").is_err());
422 assert!(
423 validate_command(&LanguageServerConfig {
424 command: "rust-analyzer".into(),
425 arguments: Vec::new()
426 })
427 .is_ok()
428 );
429 assert!(validate_actor("embedded-agent-1").is_ok());
430 assert!(validate_actor("bad\nactor").is_err());
431 }
432
433 #[test]
434 fn shared_rust_language_service_serves_multiple_actors() {
435 if !Command::new("rust-analyzer")
436 .arg("--version")
437 .output()
438 .is_ok_and(|output| output.status.success())
439 {
440 return;
441 }
442 let sequence = NEXT_ROOT.fetch_add(1, Ordering::Relaxed);
443 let root = std::env::temp_dir().join(format!(
444 "glass-shared-lsp-{}-{sequence}",
445 std::process::id()
446 ));
447 std::fs::create_dir_all(root.join("src")).unwrap();
448 std::fs::write(
449 root.join("Cargo.toml"),
450 "[package]\nname='shared_lsp_fixture'\nversion='0.1.0'\nedition='2024'\n",
451 )
452 .unwrap();
453 std::fs::write(
454 root.join("src/lib.rs"),
455 "pub fn value() -> u32 { 42 }\npub fn use_value() { val }\n",
456 )
457 .unwrap();
458 let mut service = LanguageService::new(&root).unwrap();
459 service.start_rust_analyzer().unwrap();
460 let response = service
461 .completion("rust", "human", "src/lib.rs", 2, 25)
462 .unwrap();
463 assert_eq!(response.method, "textDocument/completion");
464 let hover = service
465 .hover("rust", "embedded-agent", "src/lib.rs", 1, 8)
466 .unwrap();
467 assert_eq!(hover.method, "textDocument/hover");
468 assert_eq!(service.names().collect::<Vec<_>>(), vec!["rust"]);
469 assert_eq!(service.events(0).len(), 3);
470 service.stop("rust").unwrap();
471 drop(service);
472 std::fs::remove_dir_all(root).unwrap();
473 }
474}