612511d · helix · git.iko.soy

253

254 let lsp::ProgressParamsValue::WorkDone(work) = value;

255 let parts = match &work {

256− lsp::WorkDoneProgress::Begin(lsp::WorkDoneProgressBegin {

256+ lsp::WorkDoneProgress::Begin(lsp::WorkDoneProgressBegin {

257− title,

257+ title,

258− message,

258+ message,

259− percentage,

259+ percentage,

260− ..

260+ ..

261 }) => (Some(title), message, percentage),

262− lsp::WorkDoneProgress::Report(lsp::WorkDoneProgressReport {

262+ lsp::WorkDoneProgress::Report(lsp::WorkDoneProgressReport {

263− message,

263+ message,

264− percentage,

264+ percentage,

265− ..

265+ ..

266 }) => (None, message, percentage),

267 lsp::WorkDoneProgress::End(lsp::WorkDoneProgressEnd { message }) => {

268 if message.is_some() {

269 (None, message, &None)

270− } else {

270+ } else {

271 self.lsp_progress.end_progress(server_id, &token);

272− self.editor.clear_status();

272+ self.editor.clear_status();

273− return;

273+ return;

274− }

275 }

274 }

276− };

275+ }

276+ };

277 let token_d: &dyn std::fmt::Display = match &token {

278 lsp::NumberOrString::Number(n) => n,

279 lsp::NumberOrString::String(s) => s,

280 };

281

282 let status = match parts {

283− (Some(title), Some(message), Some(percentage)) => {

283+ (Some(title), Some(message), Some(percentage)) => {

284 format!("[{}] {}% {} - {}", token_d, percentage, title, message)

285− }

285+ }

286− (Some(title), None, Some(percentage)) => {

286+ (Some(title), None, Some(percentage)) => {

287 format!("[{}] {}% {}", token_d, percentage, title)

288− }

288+ }

289− (Some(title), Some(message), None) => {

289+ (Some(title), Some(message), None) => {

290 format!("[{}] {} - {}", token_d, title, message)

291− }

291+ }

292− (None, Some(message), Some(percentage)) => {

292+ (None, Some(message), Some(percentage)) => {

293 format!("[{}] {}% {}", token_d, percentage, message)

294− }

294+ }

295 (Some(title), None, None) => {

296 format!("[{}] {}", token_d, title)

297 }

316 _ => unreachable!(),

317 }

318 }

319− Call::MethodCall(call) => {

319+ Call::MethodCall(helix_lsp::jsonrpc::MethodCall {

320+ method,

321+ params,

322+ jsonrpc,

323+ id,

324+ }) => {

325+ let call = match MethodCall::parse(&method, params) {

326+ Some(call) => call,

327+ None => {

320− error!("Method not found {}", call.method);

328+ error!("Method not found {}", method);

329+ return;

330+ }

331+ };

321

332

333+ match call {

334+ MethodCall::WorkDoneProgressCreate(params) => {

335+ self.lsp_progress.create(server_id, params.token);

336+

337+ let doc = self.editor.documents().find(|doc| {

338+ doc.language_server()

339+ .map(|server| server.id() == server_id)

340+ .unwrap_or_default()

341+ });

342+ match doc {

343+ Some(doc) => {

344+ // it's ok to unwrap, we check for the language server before

345+ let server = doc.language_server().unwrap();

346+ tokio::spawn(server.reply(id, Ok(serde_json::Value::Null)));

347+ }

348+ None => {

349+ if let Some(server) =

350+ self.editor.language_servers.get_by_id(server_id)

351+ {

352+ log::warn!(

353+ "missing document with language server id `{}`",

354+ server_id

355+ );

356+ tokio::spawn(server.reply(

357+ id,

358+ Err(helix_lsp::jsonrpc::Error {

359+ code: helix_lsp::jsonrpc::ErrorCode::InternalError,

360+ message: "document missing".to_string(),

361+ data: None,

362+ }),

363+ ));

364+ } else {

365+ log::warn!(

366+ "can't find language server with id `{}`",

367+ server_id

368+ );

369+ }

370+ }

371+ }

372+ }

373+ }

322 // self.language_server.reply(

374 // self.language_server.reply(

323 // call.id,

375 // call.id,

324 // // TODO: make a Into trait that can cast to Err(jsonrpc::Error)

376 // // TODO: make a Into trait that can cast to Err(jsonrpc::Error)