ba97005 · helix · git.iko.soy

git.iko.soy/helix

on master help sign in

Work around the rest of the blocking issues.

ba97005Blaž Hrastnik5 years ago

Cargo.lock+12

compare with master

unifiedsplit

@@ -191,6 +191,17 @@ version = "0.3.14"

191source = "registry+https://github.com/rust-lang/crates.io-index"

192checksum = "098cd1c6dda6ca01650f1a37a794245eb73181d0d4d4e955e2f3c37db7af1815"

193

194+[[package]]

195+name = "futures-executor"

196+version = "0.3.14"

197+source = "registry+https://github.com/rust-lang/crates.io-index"

198+checksum = "10f6cb7042eda00f0049b1d2080aa4b93442997ee507eb3828e8bd7577f94c9d"

199+dependencies = [

200+ "futures-core",

201+ "futures-task",

202+ "futures-util",

203+]

204+

194[[package]]

205[[package]]

195name = "futures-macro"

206name = "futures-macro"

196version = "0.3.14"

207version = "0.3.14"

@@ -293,6 +304,7 @@ name = "helix-lsp"

293version = "0.1.0"

304version = "0.1.0"

294dependencies = [

305dependencies = [

295 "anyhow",

306 "anyhow",

307+ "futures-executor",

296 "futures-util",

308 "futures-util",

297 "glob",

309 "glob",

298 "helix-core",

310 "helix-core",

helix-lsp/Cargo.toml+1

@@ -14,6 +14,7 @@ once_cell = "1.4"

14lsp-types = { version = "0.89", features = ["proposed"] }

15tokio = { version = "1", features = ["full"] }

16tokio-stream = "0.1.5"

17+futures-executor = { version = "0.3" }

17url = "2"

18url = "2"

18pathdiff = "0.2"

19pathdiff = "0.2"

19shellexpand = "2.0"

20shellexpand = "2.0"

helix-lsp/src/client.rs+19−45

@@ -152,7 +152,7 @@ impl Client {

152

153 timeout(Duration::from_secs(2), rx.recv())

154 .await

155− .map_err(|e| Error::Timeout)? // return Timeout

155+ .map_err(|_| Error::Timeout)? // return Timeout

156 .unwrap() // TODO: None if channel closed

157 }

158 }

@@ -500,11 +500,11 @@ impl Client {

500 self.call::<lsp::request::Completion>(params)

501 }

502

503− pub async fn text_document_signature_help(

503+ pub fn text_document_signature_help(

504 &self,

505 text_document: lsp::TextDocumentIdentifier,

506 position: lsp::Position,

507− ) -> anyhow::Result<Option<lsp::SignatureHelp>> {

507+ ) -> impl Future<Output = Result<Value>> {

508 let params = lsp::SignatureHelpParams {

509 text_document_position_params: lsp::TextDocumentPositionParams {

510 text_document,

@@ -517,18 +517,14 @@ impl Client {

517 // lsp::SignatureHelpContext

518 };

519

520− let response = self

521− .request::<lsp::request::SignatureHelpRequest>(params)

520+ self.call::<lsp::request::SignatureHelpRequest>(params)

522− .await?;

523−

524− Ok(response)

525 }

521 }

526

522

527− pub async fn text_document_hover(

523+ pub fn text_document_hover(

528 &self,

524 &self,

529 text_document: lsp::TextDocumentIdentifier,

525 text_document: lsp::TextDocumentIdentifier,

530 position: lsp::Position,

526 position: lsp::Position,

531− ) -> anyhow::Result<Option<lsp::Hover>> {

527+ ) -> impl Future<Output = Result<Value>> {

532 let params = lsp::HoverParams {

528 let params = lsp::HoverParams {

533 text_document_position_params: lsp::TextDocumentPositionParams {

529 text_document_position_params: lsp::TextDocumentPositionParams {

534 text_document,

530 text_document,

@@ -540,9 +536,7 @@ impl Client {

540 // lsp::SignatureHelpContext

536 // lsp::SignatureHelpContext

541 };

537 };

542

538

543− let response = self.request::<lsp::request::HoverRequest>(params).await?;

539+ self.call::<lsp::request::HoverRequest>(params)

544−

545− Ok(response)

546 }

540 }

547

541

548 // formatting

542 // formatting

@@ -607,7 +601,7 @@ impl Client {

607 Ok(response.unwrap_or_default())

601 Ok(response.unwrap_or_default())

608 }

602 }

609

603

610− async fn goto_request<

604+ fn goto_request<

611 T: lsp::request::Request<

605 T: lsp::request::Request<

612 Params = lsp::GotoDefinitionParams,

606 Params = lsp::GotoDefinitionParams,

613 Result = Option<lsp::GotoDefinitionResponse>,

607 Result = Option<lsp::GotoDefinitionResponse>,

@@ -616,7 +610,7 @@ impl Client {

616 &self,

610 &self,

617 text_document: lsp::TextDocumentIdentifier,

611 text_document: lsp::TextDocumentIdentifier,

618 position: lsp::Position,

612 position: lsp::Position,

619− ) -> anyhow::Result<Vec<lsp::Location>> {

613+ ) -> impl Future<Output = Result<Value>> {

620 let params = lsp::GotoDefinitionParams {

614 let params = lsp::GotoDefinitionParams {

621 text_document_position_params: lsp::TextDocumentPositionParams {

615 text_document_position_params: lsp::TextDocumentPositionParams {

622 text_document,

616 text_document,

@@ -630,56 +624,38 @@ impl Client {

630 },

624 },

631 };

625 };

632

626

633− let response = self.request::<T>(params).await?;

627+ self.call::<T>(params)

634−

635− let items = match response {

636− Some(lsp::GotoDefinitionResponse::Scalar(location)) => vec![location],

637− Some(lsp::GotoDefinitionResponse::Array(locations)) => locations,

638− Some(lsp::GotoDefinitionResponse::Link(locations)) => locations

639− .into_iter()

640− .map(|location_link| lsp::Location {

641− uri: location_link.target_uri,

642− range: location_link.target_range,

643− })

644− .collect(),

645− None => Vec::new(),

646− };

647−

648− Ok(items)

649 }

628 }

650

629

651− pub async fn goto_definition(

630+ pub fn goto_definition(

652 &self,

631 &self,

653 text_document: lsp::TextDocumentIdentifier,

632 text_document: lsp::TextDocumentIdentifier,

654 position: lsp::Position,

633 position: lsp::Position,

655− ) -> anyhow::Result<Vec<lsp::Location>> {

634+ ) -> impl Future<Output = Result<Value>> {

656 self.goto_request::<lsp::request::GotoDefinition>(text_document, position)

635 self.goto_request::<lsp::request::GotoDefinition>(text_document, position)

657− .await

658 }

636 }

659

637

660− pub async fn goto_type_definition(

638+ pub fn goto_type_definition(

661 &self,

639 &self,

662 text_document: lsp::TextDocumentIdentifier,

640 text_document: lsp::TextDocumentIdentifier,

663 position: lsp::Position,

641 position: lsp::Position,

664− ) -> anyhow::Result<Vec<lsp::Location>> {

642+ ) -> impl Future<Output = Result<Value>> {

665 self.goto_request::<lsp::request::GotoTypeDefinition>(text_document, position)

643 self.goto_request::<lsp::request::GotoTypeDefinition>(text_document, position)

666− .await

667 }

644 }

668

645

669− pub async fn goto_implementation(

646+ pub fn goto_implementation(

670 &self,

647 &self,

671 text_document: lsp::TextDocumentIdentifier,

648 text_document: lsp::TextDocumentIdentifier,

672 position: lsp::Position,

649 position: lsp::Position,

673− ) -> anyhow::Result<Vec<lsp::Location>> {

650+ ) -> impl Future<Output = Result<Value>> {

674 self.goto_request::<lsp::request::GotoImplementation>(text_document, position)

651 self.goto_request::<lsp::request::GotoImplementation>(text_document, position)

675− .await

676 }

652 }

677

653

678− pub async fn goto_reference(

654+ pub fn goto_reference(

679 &self,

655 &self,

680 text_document: lsp::TextDocumentIdentifier,

656 text_document: lsp::TextDocumentIdentifier,

681 position: lsp::Position,

657 position: lsp::Position,

682− ) -> anyhow::Result<Vec<lsp::Location>> {

658+ ) -> impl Future<Output = Result<Value>> {

683 let params = lsp::ReferenceParams {

659 let params = lsp::ReferenceParams {

684 text_document_position: lsp::TextDocumentPositionParams {

660 text_document_position: lsp::TextDocumentPositionParams {

685 text_document,

661 text_document,

@@ -696,8 +672,6 @@ impl Client {

696 },

672 },

697 };

673 };

698

674

699− let response = self.request::<lsp::request::References>(params).await?;

675+ self.call::<lsp::request::References>(params)

700−

701− Ok(response.unwrap_or_default())

702 }

676 }

703}

677}

helix-lsp/src/lib.rs+1−2

@@ -203,8 +203,7 @@ impl Registry {

203 Client::start(&config.command, &config.args).ok()?;

204

205 // TODO: run this async without blocking

206− let rt = tokio::runtime::Handle::current();

207− rt.block_on(client.initialize()).unwrap();

206+ futures_executor::block_on(client.initialize()).unwrap();

208

207

209 s_incoming.push(UnboundedReceiverStream::new(incoming));

208 s_incoming.push(UnboundedReceiverStream::new(incoming));

210

209

helix-term/src/commands.rs+164−84

@@ -108,16 +108,6 @@ impl<'a> Context<'a> {

108/// state (usually by creating and applying a transaction).

109pub type Command = fn(cx: &mut Context);

110

111−#[inline]

112−fn block_on<T>(future: impl Future<Output = T>) -> T {

113− use tokio::runtime::Runtime;

114− // let rt = Runtime::new().unwrap();

115− let rt = tokio::runtime::Handle::current();

116− // let local = LocalSet::new();

117− // local.block_on(&rt, future)

118− rt.block_on(future)

119−}

120−

121pub fn move_char_left(cx: &mut Context) {

111pub fn move_char_left(cx: &mut Context) {

122 let count = cx.count;

112 let count = cx.count;

123 let (view, doc) = cx.current();

113 let (view, doc) = cx.current();

@@ -260,13 +250,13 @@ pub fn move_next_word_end(cx: &mut Context) {

260}

250}

261

251

262pub fn move_file_start(cx: &mut Context) {

252pub fn move_file_start(cx: &mut Context) {

263− push_jump(cx);

253+ push_jump(cx.editor);

264 let (view, doc) = cx.current();

254 let (view, doc) = cx.current();

265 doc.set_selection(view.id, Selection::point(0));

255 doc.set_selection(view.id, Selection::point(0));

266}

256}

267

257

268pub fn move_file_end(cx: &mut Context) {

258pub fn move_file_end(cx: &mut Context) {

269− push_jump(cx);

259+ push_jump(cx.editor);

270 let (view, doc) = cx.current();

260 let (view, doc) = cx.current();

271 let text = doc.text();

261 let text = doc.text();

272 let last_line = text.line_to_char(text.len_lines().saturating_sub(2));

262 let last_line = text.line_to_char(text.len_lines().saturating_sub(2));

@@ -880,7 +870,7 @@ pub fn command_mode(cx: &mut Context) {

880 // TODO: non-blocking via save() command

870 // TODO: non-blocking via save() command

881 let id = editor.view().doc;

871 let id = editor.view().doc;

882 let doc = &mut editor.documents[id];

872 let doc = &mut editor.documents[id];

883− block_on(doc.save());

873+ tokio::spawn(doc.save());

884 }

874 }

885

875

886 _ => (),

876 _ => (),

@@ -1079,8 +1069,8 @@ pub fn normal_mode(cx: &mut Context) {

1079}

1069}

1080

1070

1081// Store a jump on the jumplist.

1071// Store a jump on the jumplist.

1082−fn push_jump(cx: &mut Context) {

1072+fn push_jump(editor: &mut Editor) {

1083− let (view, doc) = cx.current();

1073+ let (view, doc) = editor.current();

1084 let jump = { (doc.id(), doc.selection(view.id).clone()) };

1074 let jump = { (doc.id(), doc.selection(view.id).clone()) };

1085 view.jumps.push(jump);

1075 view.jumps.push(jump);

1086}

1076}

@@ -1089,7 +1079,7 @@ pub fn goto_mode(cx: &mut Context) {

1089 let count = cx.count;

1079 let count = cx.count;

1090

1080

1091 if count > 1 {

1081 if count > 1 {

1092− push_jump(cx);

1082+ push_jump(cx.editor);

1093

1083

1094 // TODO: can't go to line 1 since we can't distinguish between g and 1g, g gets converted

1084 // TODO: can't go to line 1 since we can't distinguish between g and 1g, g gets converted

1095 // to 1g

1085 // to 1g

@@ -1127,10 +1117,15 @@ pub fn exit_select_mode(cx: &mut Context) {

1127 cx.doc().mode = Mode::Normal;

1117 cx.doc().mode = Mode::Normal;

1128}

1118}

1129

1119

1120+fn _goto(

1121+ editor: &mut Editor,

1122+ compositor: &mut Compositor,

1123+ locations: Vec<lsp::Location>,

1130−fn _goto(cx: &mut Context, locations: Vec<lsp::Location>, offset_encoding: OffsetEncoding) {

1124+ offset_encoding: OffsetEncoding,

1125+) {

1131 use helix_view::editor::Action;

1126 use helix_view::editor::Action;

1132

1127

1133− push_jump(cx);

1128+ push_jump(editor);

1134

1129

1135 fn jump_to(

1130 fn jump_to(

1136 editor: &mut Editor,

1131 editor: &mut Editor,

@@ -1152,7 +1147,7 @@ fn _goto(cx: &mut Context, locations: Vec<lsp::Location>, offset_encoding: Offse

1152

1147

1153 match locations.as_slice() {

1148 match locations.as_slice() {

1154 [location] => {

1149 [location] => {

1155− jump_to(cx.editor, location, offset_encoding, Action::Replace);

1150+ jump_to(editor, location, offset_encoding, Action::Replace);

1156 }

1151 }

1157 [] => (), // maybe show user message that no definition was found?

1152 [] => (), // maybe show user message that no definition was found?

1158 _locations => {

1153 _locations => {

@@ -1167,7 +1162,7 @@ fn _goto(cx: &mut Context, locations: Vec<lsp::Location>, offset_encoding: Offse

1167 jump_to(editor, location, offset_encoding, action)

1162 jump_to(editor, location, offset_encoding, action)

1168 },

1163 },

1169 );

1164 );

1170− cx.push_layer(Box::new(picker));

1165+ compositor.push(Box::new(picker));

1171 }

1166 }

1172 }

1167 }

1173}

1168}

@@ -1184,8 +1179,29 @@ pub fn goto_definition(cx: &mut Context) {

1184 let pos = pos_to_lsp_pos(doc.text(), doc.selection(view.id).cursor(), offset_encoding);

1179 let pos = pos_to_lsp_pos(doc.text(), doc.selection(view.id).cursor(), offset_encoding);

1185

1180

1186 // TODO: handle fails

1181 // TODO: handle fails

1187− let res = block_on(language_server.goto_definition(doc.identifier(), pos)).unwrap_or_default();

1182+ let future = language_server.goto_definition(doc.identifier(), pos);

1183+

1184+ cx.callback(

1185+ future,

1186+ move |editor: &mut Editor,

1187+ compositor: &mut Compositor,

1188+ response: Option<lsp::GotoDefinitionResponse>| {

1189+ let items = match response {

1190+ Some(lsp::GotoDefinitionResponse::Scalar(location)) => vec![location],

1191+ Some(lsp::GotoDefinitionResponse::Array(locations)) => locations,

1192+ Some(lsp::GotoDefinitionResponse::Link(locations)) => locations

1193+ .into_iter()

1194+ .map(|location_link| lsp::Location {

1195+ uri: location_link.target_uri,

1196+ range: location_link.target_range,

1197+ })

1198+ .collect(),

1199+ None => Vec::new(),

1200+ };

1201+

1188− _goto(cx, res, offset_encoding);

1202+ _goto(editor, compositor, items, offset_encoding);

1203+ },

1204+ );

1189}

1205}

1190

1206

1191pub fn goto_type_definition(cx: &mut Context) {

1207pub fn goto_type_definition(cx: &mut Context) {

@@ -1200,9 +1216,29 @@ pub fn goto_type_definition(cx: &mut Context) {

1200 let pos = pos_to_lsp_pos(doc.text(), doc.selection(view.id).cursor(), offset_encoding);

1216 let pos = pos_to_lsp_pos(doc.text(), doc.selection(view.id).cursor(), offset_encoding);

1201

1217

1202 // TODO: handle fails

1218 // TODO: handle fails

1203− let res =

1204− block_on(language_server.goto_type_definition(doc.identifier(), pos)).unwrap_or_default();

1219+ let future = language_server.goto_type_definition(doc.identifier(), pos);

1220+

1221+ cx.callback(

1222+ future,

1223+ move |editor: &mut Editor,

1224+ compositor: &mut Compositor,

1225+ response: Option<lsp::GotoDefinitionResponse>| {

1226+ let items = match response {

1227+ Some(lsp::GotoDefinitionResponse::Scalar(location)) => vec![location],

1228+ Some(lsp::GotoDefinitionResponse::Array(locations)) => locations,

1229+ Some(lsp::GotoDefinitionResponse::Link(locations)) => locations

1230+ .into_iter()

1231+ .map(|location_link| lsp::Location {

1232+ uri: location_link.target_uri,

1233+ range: location_link.target_range,

1234+ })

1235+ .collect(),

1236+ None => Vec::new(),

1237+ };

1238+

1205− _goto(cx, res, offset_encoding);

1239+ _goto(editor, compositor, items, offset_encoding);

1240+ },

1241+ );

1206}

1242}

1207

1243

1208pub fn goto_implementation(cx: &mut Context) {

1244pub fn goto_implementation(cx: &mut Context) {

@@ -1217,9 +1253,29 @@ pub fn goto_implementation(cx: &mut Context) {

1217 let pos = pos_to_lsp_pos(doc.text(), doc.selection(view.id).cursor(), offset_encoding);

1253 let pos = pos_to_lsp_pos(doc.text(), doc.selection(view.id).cursor(), offset_encoding);

1218

1254

1219 // TODO: handle fails

1255 // TODO: handle fails

1220− let res =

1221− block_on(language_server.goto_implementation(doc.identifier(), pos)).unwrap_or_default();

1256+ let future = language_server.goto_implementation(doc.identifier(), pos);

1257+

1258+ cx.callback(

1259+ future,

1260+ move |editor: &mut Editor,

1261+ compositor: &mut Compositor,

1262+ response: Option<lsp::GotoDefinitionResponse>| {

1263+ let items = match response {

1264+ Some(lsp::GotoDefinitionResponse::Scalar(location)) => vec![location],

1265+ Some(lsp::GotoDefinitionResponse::Array(locations)) => locations,

1266+ Some(lsp::GotoDefinitionResponse::Link(locations)) => locations

1267+ .into_iter()

1268+ .map(|location_link| lsp::Location {

1269+ uri: location_link.target_uri,

1270+ range: location_link.target_range,

1271+ })

1272+ .collect(),

1273+ None => Vec::new(),

1274+ };

1275+

1222− _goto(cx, res, offset_encoding);

1276+ _goto(editor, compositor, items, offset_encoding);

1277+ },

1278+ );

1223}

1279}

1224

1280

1225pub fn goto_reference(cx: &mut Context) {

1281pub fn goto_reference(cx: &mut Context) {

@@ -1234,8 +1290,21 @@ pub fn goto_reference(cx: &mut Context) {

1234 let pos = pos_to_lsp_pos(doc.text(), doc.selection(view.id).cursor(), offset_encoding);

1290 let pos = pos_to_lsp_pos(doc.text(), doc.selection(view.id).cursor(), offset_encoding);

1235

1291

1236 // TODO: handle fails

1292 // TODO: handle fails

1237− let res = block_on(language_server.goto_reference(doc.identifier(), pos)).unwrap_or_default();

1293+ let future = language_server.goto_reference(doc.identifier(), pos);

1294+

1295+ cx.callback(

1296+ future,

1297+ move |editor: &mut Editor,

1298+ compositor: &mut Compositor,

1299+ items: Option<Vec<lsp::Location>>| {

1300+ _goto(

1301+ editor,

1302+ compositor,

1303+ items.unwrap_or_default(),

1238− _goto(cx, res, offset_encoding);

1304+ offset_encoding,

1305+ );

1306+ },

1307+ );

1239}

1308}

1240

1309

1241pub fn signature_help(cx: &mut Context) {

1310pub fn signature_help(cx: &mut Context) {

@@ -1253,23 +1322,28 @@ pub fn signature_help(cx: &mut Context) {

1253 );

1322 );

1254

1323

1255 // TODO: handle fails

1324 // TODO: handle fails

1325+ let future = language_server.text_document_signature_help(doc.identifier(), pos);

1256

1326

1257− let res = block_on(language_server.text_document_signature_help(doc.identifier(), pos))

1327+ cx.callback(

1258− .unwrap_or_default();

1328+ future,

1259−

1329+ move |editor: &mut Editor,

1330+ compositor: &mut Compositor,

1331+ response: Option<lsp::SignatureHelp>| {

1260− if let Some(signature_help) = res {

1332+ if let Some(signature_help) = response {

1261− log::info!("{:?}", signature_help);

1333+ log::info!("{:?}", signature_help);

1262− // signatures

1334+ // signatures

1263− // active_signature

1335+ // active_signature

1264− // active_parameter

1336+ // active_parameter

1265− // render as:

1337+ // render as:

1266−

1338+

1267− // signature

1339+ // signature

1268− // ----------

1340+ // ----------

1269− // doc

1341+ // doc

1270−

1342+

1271− // with active param highlighted

1343+ // with active param highlighted

1272− }

1344+ }

1345+ },

1346+ );

1273}

1347}

1274

1348

1275// NOTE: Transactions in this module get appended to history when we switch back to normal mode.

1349// NOTE: Transactions in this module get appended to history when we switch back to normal mode.

@@ -1643,20 +1717,22 @@ pub fn format_selections(cx: &mut Context) {

1643 };

1717 };

1644 // TODO: handle fails

1718 // TODO: handle fails

1645 // TODO: concurrent map

1719 // TODO: concurrent map

1720+ unimplemented!(); // neeed to block to get the formatting

1721+

1646− let edits = block_on(language_server.text_document_range_formatting(

1722+ // let edits = block_on(language_server.text_document_range_formatting(

1647− doc.identifier(),

1723+ // doc.identifier(),

1648− range,

1724+ // range,

1649− lsp::FormattingOptions::default(),

1725+ // lsp::FormattingOptions::default(),

1650− ))

1726+ // ))

1651− .unwrap_or_default();

1727+ // .unwrap_or_default();

1652−

1728+

1653− let transaction = helix_lsp::util::generate_transaction_from_edits(

1729+ // let transaction = helix_lsp::util::generate_transaction_from_edits(

1654− doc.text(),

1730+ // doc.text(),

1655− edits,

1731+ // edits,

1656− language_server.offset_encoding(),

1732+ // language_server.offset_encoding(),

1657− );

1733+ // );

1658−

1734+

1659− doc.apply(&transaction, view.id);

1735+ // doc.apply(&transaction, view.id);

1660 }

1736 }

1661

1737

1662 doc.append_changes_to_history(view.id);

1738 doc.append_changes_to_history(view.id);

@@ -1734,7 +1810,7 @@ pub fn save(cx: &mut Context) {

1734

1810

1735 // TODO: handle save errors somehow?

1811 // TODO: handle save errors somehow?

1736 // TODO: don't block

1812 // TODO: don't block

1737− block_on(cx.doc().save());

1813+ tokio::spawn(cx.doc().save());

1738}

1814}

1739

1815

1740pub fn completion(cx: &mut Context) {

1816pub fn completion(cx: &mut Context) {

@@ -1847,30 +1923,34 @@ pub fn hover(cx: &mut Context) {

1847 );

1923 );

1848

1924

1849 // TODO: handle fails

1925 // TODO: handle fails

1850− let res =

1851− block_on(language_server.text_document_hover(doc.identifier(), pos)).unwrap_or_default();

1926+ let future = language_server.text_document_hover(doc.identifier(), pos);

1852−

1853− if let Some(hover) = res {

1854− // hover.contents / .range <- used for visualizing

1855− let contents = match hover.contents {

1856− lsp::HoverContents::Scalar(contents) => {

1857− // markedstring(string/languagestring to be highlighted)

1858− // TODO

1859− unimplemented!("{:?}", contents)

1860− }

1861− lsp::HoverContents::Array(contents) => {

1862− unimplemented!("{:?}", contents)

1863− }

1864− // TODO: render markdown

1865− lsp::HoverContents::Markup(contents) => contents.value,

1866− };

1867

1927

1868− // skip if contents empty

1928+ cx.callback(

1929+ future,

1930+ move |editor: &mut Editor, compositor: &mut Compositor, response: Option<lsp::Hover>| {

1931+ if let Some(hover) = response {

1932+ // hover.contents / .range <- used for visualizing

1933+ let contents = match hover.contents {

1934+ lsp::HoverContents::Scalar(contents) => {

1935+ // markedstring(string/languagestring to be highlighted)

1936+ // TODO

1937+ unimplemented!("{:?}", contents)

1938+ }

1939+ lsp::HoverContents::Array(contents) => {

1940+ unimplemented!("{:?}", contents)

1941+ }

1942+ // TODO: render markdown

1943+ lsp::HoverContents::Markup(contents) => contents.value,

1944+ };

1869

1945

1946+ // skip if contents empty

1947+

1870− let contents = ui::Markdown::new(contents);

1948+ let contents = ui::Markdown::new(contents);

1871− let mut popup = Popup::new(contents);

1949+ let mut popup = Popup::new(contents);

1872− cx.push_layer(Box::new(popup));

1950+ compositor.push(Box::new(popup));

1873− }

1951+ }

1952+ },

1953+ );

1874}

1954}

1875

1955

1876// view movements

1956// view movements

@@ -1971,7 +2051,7 @@ pub fn space_mode(cx: &mut Context) {

1971 'w' => {

2051 'w' => {

1972 // save current buffer

2052 // save current buffer

1973 let doc = cx.doc();

2053 let doc = cx.doc();

1974− block_on(doc.save());

2054+ tokio::spawn(doc.save());

1975 }

2055 }

1976 'c' => {

2056 'c' => {

1977 // close current split

2057 // close current split