63e191e · helix · git.iko.soy

4

5use crate::{args::Args, compositor::Compositor, config::Config, job::Jobs, ui};

6

7−use log::error;

7+use log::{error, warn};

8

9use std::{

10 io::{stdout, Write},

429 Call::MethodCall(helix_lsp::jsonrpc::MethodCall {

430 method, params, id, ..

431 }) => {

432+ let language_server = match self.editor.language_servers.get_by_id(server_id) {

433+ Some(language_server) => language_server,

434+ None => {

435+ warn!("can't find language server with id `{}`", server_id);

436+ return;

437+ }

438+ };

439+

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

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

433 Some(call) => call,

441 Some(call) => call,

434 None => {

442 None => {

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

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

444+ // language_server.reply(

445+ // call.id,

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

447+ // Err(helix_lsp::jsonrpc::Error {

448+ // code: helix_lsp::jsonrpc::ErrorCode::MethodNotFound,

449+ // message: "Method not found".to_string(),

450+ // data: None,

451+ // }),

452+ // );

436 return;

453 return;

437 }

454 }

438 };

455 };

445 if spinner.is_stopped() {

462 if spinner.is_stopped() {

446 spinner.start();

463 spinner.start();

447 }

464 }

448−

449− let doc = self.editor.documents().find(|doc| {

450− doc.language_server()

451− .map(|server| server.id() == server_id)

452− .unwrap_or_default()

453− });

454− match doc {

455− Some(doc) => {

456− // it's ok to unwrap, we check for the language server before

457− let server = doc.language_server().unwrap();

458− tokio::spawn(server.reply(id, Ok(serde_json::Value::Null)));

465+ tokio::spawn(language_server.reply(id, Ok(serde_json::Value::Null)));

459− }

460− None => {

461− if let Some(server) =

462− self.editor.language_servers.get_by_id(server_id)

463− {

464− log::warn!(

465− "missing document with language server id `{}`",

466− server_id

467− );

468− tokio::spawn(server.reply(

469− id,

470− Err(helix_lsp::jsonrpc::Error {

471− code: helix_lsp::jsonrpc::ErrorCode::InternalError,

472− message: "document missing".to_string(),

473− data: None,

474− }),

475− ));

476− } else {

477− log::warn!(

478− "can't find language server with id `{}`",

479− server_id

480− );

481− }

482− }

483− }

484 }

466 }

485 }

467 }

486− // self.language_server.reply(

487− // call.id,

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

489− // Err(helix_lsp::jsonrpc::Error {

490− // code: helix_lsp::jsonrpc::ErrorCode::MethodNotFound,

491− // message: "Method not found".to_string(),

492− // data: None,

493− // }),

494− // );

495 }

468 }

496 e => unreachable!("{:?}", e),

469 e => unreachable!("{:?}", e),

497 }

470 }