From 8adcf5083ffc12532ecca7594a2192acd954dd3a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Hrastnik?= Date: Thu, 15 Oct 2020 23:32:07 +0900 Subject: [PATCH 01/23] wip --- Cargo.lock | 302 +++++++++++++++++++++++++++++++++++++++++++ Cargo.toml | 1 + helix-lsp/Cargo.toml | 15 +++ helix-lsp/src/lib.rs | 71 ++++++++++ 4 files changed, 389 insertions(+) create mode 100644 helix-lsp/Cargo.toml create mode 100644 helix-lsp/src/lib.rs diff --git a/Cargo.lock b/Cargo.lock index 0a3137d9e..9333a5186 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -21,6 +21,18 @@ version = "0.4.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4d25d88fd6b8041580a654f9d0c581a047baee2b3efee13275f2fc392fc75034" +[[package]] +name = "arrayref" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4c527152e37cf757a3f78aae5a06fbeefdb07ccc535c980a3208ee3060dd544" + +[[package]] +name = "arrayvec" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cff77d8686867eceff3105329d4698d96c2391c176d5d03adc90c7389162b5b8" + [[package]] name = "async-channel" version = "1.5.1" @@ -132,12 +144,29 @@ version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a" +[[package]] +name = "base64" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3441f0f7b02788e948e47f457ca01f1d7e6d92c693bc132c22b087d3141c03ff" + [[package]] name = "bitflags" version = "1.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693" +[[package]] +name = "blake2b_simd" +version = "0.5.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8fb2d74254a3a0b5cac33ac9f8ed0e44aa50378d9dbb2e5d83bd21ed1dc2c8a" +dependencies = [ + "arrayref", + "arrayvec", + "constant_time_eq", +] + [[package]] name = "blocking" version = "1.0.2" @@ -212,6 +241,23 @@ dependencies = [ "cache-padded", ] +[[package]] +name = "constant_time_eq" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc" + +[[package]] +name = "crossbeam-utils" +version = "0.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3c7c73a2d1e9fc0886a08b93e98eb643461230d5f1925e4036204d5f2e261a8" +dependencies = [ + "autocfg", + "cfg-if", + "lazy_static", +] + [[package]] name = "crossterm" version = "0.18.0" @@ -238,6 +284,27 @@ dependencies = [ "winapi", ] +[[package]] +name = "dirs" +version = "2.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13aea89a5c93364a98e9b37b2fa237effbb694d5cfe01c5b70941f7eb087d5e3" +dependencies = [ + "cfg-if", + "dirs-sys", +] + +[[package]] +name = "dirs-sys" +version = "0.3.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e93d7f5705de3e49895a2b5e0b8855a1c27f080192ae9c32a6432d50741a57a" +dependencies = [ + "libc", + "redox_users", + "winapi", +] + [[package]] name = "event-listener" version = "2.5.1" @@ -290,6 +357,23 @@ dependencies = [ "waker-fn", ] +[[package]] +name = "getrandom" +version = "0.1.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc587bc0ec293155d5bfa6b9891ec18a1e330c234f896ea47fbada4cadbe47e6" +dependencies = [ + "cfg-if", + "libc", + "wasi", +] + +[[package]] +name = "glob" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574" + [[package]] name = "hashbrown" version = "0.9.1" @@ -312,6 +396,18 @@ dependencies = [ "unicode-width", ] +[[package]] +name = "helix-lsp" +version = "0.1.0" +dependencies = [ + "glob", + "lsp-types", + "pathdiff", + "shellexpand", + "smol", + "url", +] + [[package]] name = "helix-syntax" version = "0.1.0" @@ -354,6 +450,17 @@ dependencies = [ "libc", ] +[[package]] +name = "idna" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "02e2673c30ee86b5b96a9cb52ad15718aa1f966f5ab9ad54a8b95d5ca33120a9" +dependencies = [ + "matches", + "unicode-bidi", + "unicode-normalization", +] + [[package]] name = "indexmap" version = "1.6.0" @@ -373,6 +480,12 @@ dependencies = [ "cfg-if", ] +[[package]] +name = "itoa" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc6f3ad7b9d11a0c00842ff8de1b60ee58661048eb8049ed33c73594f359d7e6" + [[package]] name = "jobserver" version = "0.1.21" @@ -412,12 +525,32 @@ dependencies = [ "cfg-if", ] +[[package]] +name = "lsp-types" +version = "0.82.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db895abb8527cf59e3de893ab2acf52cf904faeb65e60ea6f373e11fe86464e8" +dependencies = [ + "base64", + "bitflags", + "serde", + "serde_json", + "serde_repr", + "url", +] + [[package]] name = "mac" version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4" +[[package]] +name = "matches" +version = "0.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ffc5c5338469d4d3ea17d269fa8ea3512ad247247c30bd2df69e68309ed0a08" + [[package]] name = "memchr" version = "2.3.3" @@ -526,6 +659,18 @@ dependencies = [ "winapi", ] +[[package]] +name = "pathdiff" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "877630b3de15c0b64cc52f659345724fbf6bdad9bd9566699fc53688f3c34a34" + +[[package]] +name = "percent-encoding" +version = "2.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e" + [[package]] name = "pin-project-lite" version = "0.1.10" @@ -545,12 +690,41 @@ dependencies = [ "winapi", ] +[[package]] +name = "proc-macro2" +version = "1.0.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e0704ee1a7e00d7bb417d0770ea303c1bccbabf0ef1667dae92b5967f5f8a71" +dependencies = [ + "unicode-xid", +] + +[[package]] +name = "quote" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa563d17ecb180e500da1cfd2b028310ac758de548efdd203e18f283af693f37" +dependencies = [ + "proc-macro2", +] + [[package]] name = "redox_syscall" version = "0.1.57" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "41cc0f7e4d5d4544e8861606a285bb08d3e70712ccc7d2b84d7c0ccfaf4b05ce" +[[package]] +name = "redox_users" +version = "0.3.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "de0737333e7a9502c789a36d7c7fa6092a49895d4faa31ca5df163857ded2e9d" +dependencies = [ + "getrandom", + "redox_syscall", + "rust-argon2", +] + [[package]] name = "regex" version = "1.4.1" @@ -578,12 +752,81 @@ dependencies = [ "smallvec", ] +[[package]] +name = "rust-argon2" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9dab61250775933275e84053ac235621dfb739556d5c54a2f2e9313b7cf43a19" +dependencies = [ + "base64", + "blake2b_simd", + "constant_time_eq", + "crossbeam-utils", +] + +[[package]] +name = "ryu" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e" + [[package]] name = "scopeguard" version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd" +[[package]] +name = "serde" +version = "1.0.116" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96fe57af81d28386a513cbc6858332abc6117cfdb5999647c6444b8f43a370a5" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.116" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f630a6370fd8e457873b4bd2ffdae75408bc291ba72be773772a4c2a065d9ae8" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.59" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dcac07dbffa1c65e7f816ab9eba78eb142c6d44410f4eeba1e26e4f5dfa56b95" +dependencies = [ + "itoa", + "ryu", + "serde", +] + +[[package]] +name = "serde_repr" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2dc6b7951b17b051f3210b063f12cc17320e2fe30ae05b0fe2a3abb068551c76" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "shellexpand" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a2b22262a9aaf9464d356f656fea420634f78c881c5eebd5ef5e66d8b9bc603" +dependencies = [ + "dirs", +] + [[package]] name = "signal-hook" version = "0.1.16" @@ -641,6 +884,17 @@ dependencies = [ "winapi", ] +[[package]] +name = "syn" +version = "1.0.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e03e57e4fcbfe7749842d53e24ccb9aa12b7252dbe5e91d2acad31834c8b8fdd" +dependencies = [ + "proc-macro2", + "quote", + "unicode-xid", +] + [[package]] name = "tendril" version = "0.4.1" @@ -669,6 +923,12 @@ dependencies = [ "lazy_static", ] +[[package]] +name = "tinyvec" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "238ce071d267c5710f9d31451efec16c5ee22de34df17cc05e56cbc92e967117" + [[package]] name = "tree-sitter" version = "0.17.0" @@ -691,6 +951,24 @@ dependencies = [ "unicode-width", ] +[[package]] +name = "unicode-bidi" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "49f2bd0c6468a8230e1db229cff8029217cf623c767ea5d60bfbd42729ea54d5" +dependencies = [ + "matches", +] + +[[package]] +name = "unicode-normalization" +version = "0.1.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6fb19cf769fa8c6a80a162df694621ebeb4dafb606470b2b2fce0be40a98a977" +dependencies = [ + "tinyvec", +] + [[package]] name = "unicode-segmentation" version = "1.6.0" @@ -703,6 +981,24 @@ version = "0.1.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9337591893a19b88d8d87f2cec1e73fad5cdfd10e5a6f349f498ad6ea2ffb1e3" +[[package]] +name = "unicode-xid" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f7fe0bb3479651439c9112f72b6c505038574c9fbb575ed1bf3b797fa39dd564" + +[[package]] +name = "url" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "829d4a8476c35c9bf0bbce5a3b23f4106f79728039b726d292bb93bc106787cb" +dependencies = [ + "idna", + "matches", + "percent-encoding", + "serde", +] + [[package]] name = "utf-8" version = "0.7.5" @@ -727,6 +1023,12 @@ version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9d5b2c62b4012a3e1eca5a7e077d13b3bf498c4073e33ccd58626607748ceeca" +[[package]] +name = "wasi" +version = "0.9.0+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519" + [[package]] name = "wepoll-sys" version = "3.0.0" diff --git a/Cargo.toml b/Cargo.toml index 25dbe725d..d7dab22ed 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -4,6 +4,7 @@ members = [ "helix-view", "helix-term", "helix-syntax", + "helix-lsp", ] # Build helix-syntax in release mode to make the code path faster in development. diff --git a/helix-lsp/Cargo.toml b/helix-lsp/Cargo.toml new file mode 100644 index 000000000..6fd59bf42 --- /dev/null +++ b/helix-lsp/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "helix-lsp" +version = "0.1.0" +authors = ["Blaž Hrastnik "] +edition = "2018" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +lsp-types = { version = "0.82", features = ["proposed"] } +smol = "1.2" +url = "2.1.1" +pathdiff = "0.2.0" +shellexpand = "2.0.0" +glob = "0.3.0" diff --git a/helix-lsp/src/lib.rs b/helix-lsp/src/lib.rs new file mode 100644 index 000000000..14d53bea8 --- /dev/null +++ b/helix-lsp/src/lib.rs @@ -0,0 +1,71 @@ +use std::{ + collections::HashMap, + process::{ChildStderr, ChildStdin, ChildStdout, Command, Stdio}, +}; + +use smol::io::{BufReader, BufWriter}; +use smol::prelude::*; +use smol::Unblock; + +struct Client { + // process: Command, + reader: BufReader>, +} + +impl Client { + fn start(cmd: &str, args: &[String]) -> Self { + let mut process = Command::new(cmd) + .args(args) + .stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .spawn() + .expect("Failed to start language server"); + // TODO: impl drop that kills the process + + // TODO: do we need bufreader/writer here? or do we use async wrappers on unblock? + let writer = BufWriter::new(Unblock::new( + process.stdin.take().expect("Failed to open stdin"), + )); + let reader = BufReader::new(Unblock::new( + process.stdout.take().expect("Failed to open stdout"), + )); + let stderr = BufReader::new(Unblock::new( + process.stderr.take().expect("Failed to open stderr"), + )); + + Client { reader } + } + + async fn receiver(&mut self) -> Result<(), std::io::Error> { + let mut headers: HashMap = HashMap::default(); + loop { + // read headers + loop { + let mut header = String::new(); + // detect pipe closed if 0 + self.reader.read_line(&mut header).await?; + let header = header.trim(); + + if header.is_empty() { + break; + } + + let parts: Vec<&str> = header.split(": ").collect(); + if parts.len() != 2 { + // return Err(Error::new(ErrorKind::Other, "Failed to parse header")); + panic!() + } + headers.insert(parts[0].to_string(), parts[1].to_string()); + } + + // find content-length + + // read data + // decode via serde_json decoding into jsonrpc_core Output + break; + } + + Ok(()) + } +} From f03830b047f0db9d9bb4576f771b5988329be46f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Hrastnik?= Date: Sun, 18 Oct 2020 18:01:06 +0900 Subject: [PATCH 02/23] wip: Basic LSP lifecycle requests/notifications. --- Cargo.lock | 106 +++++++++++ helix-lsp/Cargo.toml | 9 +- helix-lsp/src/lib.rs | 390 ++++++++++++++++++++++++++++++++++++----- helix-term/Cargo.toml | 1 + helix-term/src/main.rs | 11 +- 5 files changed, 470 insertions(+), 47 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 9333a5186..999a55b11 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -330,6 +330,12 @@ dependencies = [ "new_debug_unreachable", ] +[[package]] +name = "futures" +version = "0.1.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c7e4c2612746b0df8fed4ce0c69156021b704c9aefa360311c04e6e9e002eed" + [[package]] name = "futures-core" version = "0.3.6" @@ -357,6 +363,43 @@ dependencies = [ "waker-fn", ] +[[package]] +name = "futures-macro" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f57ed14da4603b2554682e9f2ff3c65d7567b53188db96cb71538217fc64581b" +dependencies = [ + "proc-macro-hack", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "futures-task" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4dd26820a9f3637f1302da8bceba3ff33adbe53464b54ca24d4e2d4f1db30f94" +dependencies = [ + "once_cell", +] + +[[package]] +name = "futures-util" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a894a0acddba51a2d49a6f4263b1e64b8c579ece8af50fa86503d52cd1eea34" +dependencies = [ + "futures-core", + "futures-macro", + "futures-task", + "pin-project", + "pin-utils", + "proc-macro-hack", + "proc-macro-nested", + "slab", +] + [[package]] name = "getrandom" version = "0.1.15" @@ -400,9 +443,14 @@ dependencies = [ name = "helix-lsp" version = "0.1.0" dependencies = [ + "anyhow", + "futures-util", "glob", + "jsonrpc-core", "lsp-types", "pathdiff", + "serde", + "serde_json", "shellexpand", "smol", "url", @@ -424,6 +472,7 @@ dependencies = [ "clap", "crossterm", "helix-core", + "helix-lsp", "helix-view", "num_cpus", "smol", @@ -495,6 +544,19 @@ dependencies = [ "libc", ] +[[package]] +name = "jsonrpc-core" +version = "15.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0745a6379e3edc893c84ec203589790774e4247420033e71a76d3ab4687991fa" +dependencies = [ + "futures", + "log", + "serde", + "serde_derive", + "serde_json", +] + [[package]] name = "lazy_static" version = "1.4.0" @@ -671,12 +733,38 @@ version = "2.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e" +[[package]] +name = "pin-project" +version = "0.4.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2ffbc8e94b38ea3d2d8ba92aea2983b503cd75d0888d75b86bb37970b5698e15" +dependencies = [ + "pin-project-internal", +] + +[[package]] +name = "pin-project-internal" +version = "0.4.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65ad2ae56b6abe3a1ee25f15ee605bacadb9a764edaba9c2bf4103800d4a1895" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "pin-project-lite" version = "0.1.10" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e555d9e657502182ac97b539fb3dae8b79cda19e3e4f8ffb5e8de4f18df93c95" +[[package]] +name = "pin-utils" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" + [[package]] name = "polling" version = "2.0.1" @@ -690,6 +778,18 @@ dependencies = [ "winapi", ] +[[package]] +name = "proc-macro-hack" +version = "0.5.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "99c605b9a0adc77b7211c6b1f722dcb613d68d66859a44f3d485a6da332b0598" + +[[package]] +name = "proc-macro-nested" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eba180dafb9038b050a4c280019bbedf9f2467b61e5d892dcad585bb57aadc5a" + [[package]] name = "proc-macro2" version = "1.0.24" @@ -848,6 +948,12 @@ dependencies = [ "libc", ] +[[package]] +name = "slab" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8" + [[package]] name = "smallvec" version = "1.4.2" diff --git a/helix-lsp/Cargo.toml b/helix-lsp/Cargo.toml index 6fd59bf42..1942fc24a 100644 --- a/helix-lsp/Cargo.toml +++ b/helix-lsp/Cargo.toml @@ -9,7 +9,12 @@ edition = "2018" [dependencies] lsp-types = { version = "0.82", features = ["proposed"] } smol = "1.2" -url = "2.1.1" +url = "2" pathdiff = "0.2.0" shellexpand = "2.0.0" -glob = "0.3.0" +glob = "0.3" +anyhow = "1" +serde_json = "1.0" +serde = { version = "1.0", features = ["derive"] } +jsonrpc-core = "15.1" +futures-util = "0.3" diff --git a/helix-lsp/src/lib.rs b/helix-lsp/src/lib.rs index 14d53bea8..b371f3376 100644 --- a/helix-lsp/src/lib.rs +++ b/helix-lsp/src/lib.rs @@ -1,19 +1,44 @@ -use std::{ - collections::HashMap, - process::{ChildStderr, ChildStdin, ChildStdout, Command, Stdio}, -}; +use std::collections::HashMap; +use jsonrpc_core as jsonrpc; +use lsp_types as lsp; + +use serde::{Deserialize, Serialize}; +use serde_json::Value; + +use smol::channel::{Receiver, Sender}; use smol::io::{BufReader, BufWriter}; use smol::prelude::*; -use smol::Unblock; +use smol::process::{Child, ChildStderr, ChildStdin, ChildStdout, Command, Stdio}; +use smol::Executor; + +use futures_util::{select, FutureExt}; + +/// A type representing all possible values sent from the server to the client. +#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +#[serde(untagged)] +enum Message { + /// A regular JSON-RPC request output (single response). + Output(jsonrpc::Output), + /// A notification. + Notification(jsonrpc::Notification), + /// A JSON-RPC request + Call(jsonrpc::Call), +} + +pub struct Client { + process: Child, + stderr: BufReader, + outgoing: Sender, + + pub request_counter: u64, -struct Client { - // process: Command, - reader: BufReader>, + capabilities: Option, } impl Client { - fn start(cmd: &str, args: &[String]) -> Self { + pub fn start(ex: &Executor, cmd: &str, args: &[String]) -> Self { let mut process = Command::new(cmd) .args(args) .stdin(Stdio::piped()) @@ -21,51 +46,332 @@ impl Client { .stderr(Stdio::piped()) .spawn() .expect("Failed to start language server"); - // TODO: impl drop that kills the process + // smol makes sure the process is reaped on drop, but using kill_on_drop(true) maybe? // TODO: do we need bufreader/writer here? or do we use async wrappers on unblock? - let writer = BufWriter::new(Unblock::new( - process.stdin.take().expect("Failed to open stdin"), - )); - let reader = BufReader::new(Unblock::new( - process.stdout.take().expect("Failed to open stdout"), - )); - let stderr = BufReader::new(Unblock::new( - process.stderr.take().expect("Failed to open stderr"), - )); + let writer = BufWriter::new(process.stdin.take().expect("Failed to open stdin")); + let reader = BufReader::new(process.stdout.take().expect("Failed to open stdout")); + let stderr = BufReader::new(process.stderr.take().expect("Failed to open stderr")); + + let (incoming, outgoing) = Transport::start(ex, reader, writer); + + Client { + process, + stderr, + outgoing, + + request_counter: 0, + + capabilities: None, + } + } + + fn next_request_id(&mut self) -> jsonrpc::Id { + let id = jsonrpc::Id::Num(self.request_counter); + self.request_counter += 1; + id + } + + fn to_params(value: Value) -> anyhow::Result { + use jsonrpc::Params; + + let params = match value { + Value::Null => Params::None, + Value::Bool(_) | Value::Number(_) | Value::String(_) => Params::Array(vec![value]), + Value::Array(vec) => Params::Array(vec), + Value::Object(map) => Params::Map(map), + }; + + Ok(params) + } + + pub async fn request( + &mut self, + params: R::Params, + ) -> anyhow::Result + where + R::Params: serde::Serialize, + R::Result: core::fmt::Debug, // TODO: temporary + { + let params = serde_json::to_value(params)?; + + let request = jsonrpc::MethodCall { + jsonrpc: Some(jsonrpc::Version::V2), + id: self.next_request_id(), + method: R::METHOD.to_string(), + params: Self::to_params(params)?, + }; + + let (tx, rx) = smol::channel::bounded::>(1); + + self.outgoing + .send(Payload::Request { + chan: tx, + value: request, + }) + .await?; + + let response = rx.recv().await??; + + let response = serde_json::from_value(response)?; + + // TODO: we should pass request to a sender thread via a channel + // so it can't be interleaved + + // TODO: responses can be out of order, we need to register a single shot response channel + + Ok(response) + } + + pub async fn notify( + &mut self, + params: R::Params, + ) -> anyhow::Result<()> + where + R::Params: serde::Serialize, + { + let params = serde_json::to_value(params)?; + + let notification = jsonrpc::Notification { + jsonrpc: Some(jsonrpc::Version::V2), + method: R::METHOD.to_string(), + params: Self::to_params(params)?, + }; + + self.outgoing + .send(Payload::Notification(notification)) + .await?; + + Ok(()) + } + + // ------------------------------------------------------------------------------------------- + // General messages + // ------------------------------------------------------------------------------------------- + + pub async fn initialize(&mut self) -> anyhow::Result<()> { + // TODO: delay any requests that are triggered prior to initialize + + #[allow(deprecated)] + let params = lsp::InitializeParams { + process_id: Some(u64::from(std::process::id())), + root_path: None, + // root_uri: Some(lsp_types::Url::parse("file://localhost/")?), + root_uri: None, // set to project root in the future + initialization_options: None, + capabilities: lsp::ClientCapabilities::default(), + trace: None, + workspace_folders: None, + client_info: None, + }; + + let response = self.request::(params).await?; + self.capabilities = Some(response.capabilities); + + // next up, notify + self.notify::(lsp::InitializedParams {}) + .await?; + + Ok(()) + } + + pub async fn shutdown(&mut self) -> anyhow::Result<()> { + self.request::(()).await + } + + pub async fn exit(&mut self) -> anyhow::Result<()> { + self.notify::(()).await + } + + // ------------------------------------------------------------------------------------------- + // Text document + // ------------------------------------------------------------------------------------------- + + pub async fn text_document_did_open(&mut self) -> anyhow::Result<()> { + self.notify::(lsp::DidOpenTextDocumentParams { + text_document: lsp::TextDocumentItem { + uri: lsp::Url::parse(".")?, + language_id: "rust".to_string(), + version: 0, + text: "".to_string(), + }, + }) + .await + } - Client { reader } + pub async fn text_document_did_change(&mut self) -> anyhow::Result<()> { + unimplemented!() } - async fn receiver(&mut self) -> Result<(), std::io::Error> { - let mut headers: HashMap = HashMap::default(); + // will_save / will_save_wait_until + + pub async fn text_document_did_save(&mut self) -> anyhow::Result<()> { + unimplemented!() + } + + pub async fn text_document_did_close(&mut self) -> anyhow::Result<()> { + unimplemented!() + } +} + +enum Payload { + Request { + chan: Sender>, + value: jsonrpc::MethodCall, + }, + Notification(jsonrpc::Notification), +} + +struct Transport { + incoming: Sender, + outgoing: Receiver, + + pending_requests: HashMap>>, + headers: HashMap, + + writer: BufWriter, + reader: BufReader, +} + +impl Transport { + pub fn start( + ex: &Executor, + reader: BufReader, + writer: BufWriter, + ) -> (Receiver, Sender) { + let (incoming, rx) = smol::channel::unbounded(); + let (tx, outgoing) = smol::channel::unbounded(); + + let transport = Self { + reader, + writer, + incoming, + outgoing, + pending_requests: Default::default(), + headers: Default::default(), + }; + + ex.spawn(transport.duplex()).detach(); + + (rx, tx) + } + + async fn recv( + reader: &mut (impl AsyncBufRead + Unpin), + headers: &mut HashMap, + ) -> Result { + // read headers loop { - // read headers - loop { - let mut header = String::new(); - // detect pipe closed if 0 - self.reader.read_line(&mut header).await?; - let header = header.trim(); - - if header.is_empty() { - break; - } + let mut header = String::new(); + // detect pipe closed if 0 + reader.read_line(&mut header).await?; + let header = header.trim(); - let parts: Vec<&str> = header.split(": ").collect(); - if parts.len() != 2 { - // return Err(Error::new(ErrorKind::Other, "Failed to parse header")); - panic!() - } - headers.insert(parts[0].to_string(), parts[1].to_string()); + if header.is_empty() { + break; } - // find content-length + let parts: Vec<&str> = header.split(": ").collect(); + if parts.len() != 2 { + // return Err(Error::new(ErrorKind::Other, "Failed to parse header")); + panic!() + } + headers.insert(parts[0].to_string(), parts[1].to_string()); + } + + // find content-length + let content_length = headers.get("Content-Length").unwrap().parse().unwrap(); + + let mut content = vec![0; content_length]; + reader.read_exact(&mut content).await?; + let msg = String::from_utf8(content).unwrap(); + + // read data + + // try parsing as output (server response) or call (server request) + let output: serde_json::Result = serde_json::from_str(&msg); - // read data - // decode via serde_json decoding into jsonrpc_core Output - break; + Ok(output?) + } + + pub async fn send_payload(&mut self, payload: Payload) -> anyhow::Result<()> { + match payload { + Payload::Request { chan, value } => { + self.pending_requests.insert(value.id.clone(), chan); + + let json = serde_json::to_string(&value)?; + self.send(json).await + } + Payload::Notification(value) => { + let json = serde_json::to_string(&value)?; + self.send(json).await + } } + } + + pub async fn send(&mut self, request: String) -> anyhow::Result<()> { + println!("-> {}", request); + + // send the headers + self.writer + .write_all(format!("Content-Length: {}\r\n\r\n", request.len()).as_bytes()) + .await?; + + // send the body + self.writer.write_all(request.as_bytes()).await?; + + self.writer.flush().await?; Ok(()) } + + pub async fn recv_response(&mut self, output: jsonrpc::Output) -> anyhow::Result<()> { + match output { + jsonrpc::Output::Success(jsonrpc::Success { id, result, .. }) => { + println!("<- {}", result); + + let tx = self + .pending_requests + .remove(&id) + .expect("pending_request with id not found!"); + tx.send(Ok(result)).await?; + } + jsonrpc::Output::Failure(_) => panic!("recv fail"), + msg => unimplemented!("{:?}", msg), + } + Ok(()) + } + + pub async fn duplex(mut self) { + loop { + select! { + // client -> server + msg = self.outgoing.next().fuse() => { + if msg.is_none() { + break; + } + let msg = msg.unwrap(); + + self.send_payload(msg).await.unwrap(); + } + // server <- client + msg = Self::recv(&mut self.reader, &mut self.headers).fuse() => { + if msg.is_err() { + break; + } + let msg = msg.unwrap(); + + match msg { + Message::Output(output) => self.recv_response(output).await.unwrap(), + Message::Notification(_) => { + // dispatch + } + Message::Call(_) => { + // dispatch + } + }; + } + } + } + } } diff --git a/helix-term/Cargo.toml b/helix-term/Cargo.toml index ed5460905..aa91a095d 100644 --- a/helix-term/Cargo.toml +++ b/helix-term/Cargo.toml @@ -14,6 +14,7 @@ path = "src/main.rs" [dependencies] helix-core = { path = "../helix-core" } helix-view = { path = "../helix-view", features = ["term"]} +helix-lsp = { path = "../helix-lsp"} anyhow = "1" diff --git a/helix-term/src/main.rs b/helix-term/src/main.rs index e14a328f5..c35c84d21 100644 --- a/helix-term/src/main.rs +++ b/helix-term/src/main.rs @@ -26,9 +26,14 @@ fn main() -> Result<(), Error> { std::thread::spawn(move || smol::block_on(EX.run(smol::future::pending::<()>()))); } - smol::block_on(EX.run(async { - Application::new(args).unwrap().run().await; - })); + let mut lsp = helix_lsp::Client::start(&EX, "rust-analyzer", &[]); + + smol::block_on(async { + let res = lsp.initialize().await; + // Application::new(args).unwrap().run().await; + + loop {} + }); Ok(()) } From 13cb442850ac3cd4b884a62711f0eb8740270d74 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Hrastnik?= Date: Mon, 19 Oct 2020 16:09:44 +0900 Subject: [PATCH 03/23] wip: Fetching diagnostics, parsing notifications. --- Cargo.lock | 21 ++-- helix-lsp/Cargo.toml | 2 + helix-lsp/log | 45 +++++++ helix-lsp/src/lib.rs | 243 ++++++++++--------------------------- helix-lsp/src/transport.rs | 189 +++++++++++++++++++++++++++++ helix-term/src/main.rs | 6 +- 6 files changed, 316 insertions(+), 190 deletions(-) create mode 100644 helix-lsp/log create mode 100644 helix-lsp/src/transport.rs diff --git a/Cargo.lock b/Cargo.lock index 999a55b11..c4beee76a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -128,9 +128,9 @@ dependencies = [ [[package]] name = "async-task" -version = "4.0.2" +version = "4.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8ab27c1aa62945039e44edaeee1dc23c74cc0c303dd5fe0fb462a184f1c3a518" +checksum = "e91831deabf0d6d7ec49552e489aed63b7456a7a3c46cff62adad428110b0af0" [[package]] name = "atomic-waker" @@ -446,6 +446,7 @@ dependencies = [ "anyhow", "futures-util", "glob", + "helix-core", "jsonrpc-core", "lsp-types", "pathdiff", @@ -767,9 +768,9 @@ checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" [[package]] name = "polling" -version = "2.0.1" +version = "2.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ab773feb154f12c49ffcfd66ab8bdcf9a1843f950db48b0d8be9d4393783b058" +checksum = "a2a7bc6b2a29e632e45451c941832803a18cce6781db04de8a04696cdca8bde4" dependencies = [ "cfg-if", "libc", @@ -878,18 +879,18 @@ checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd" [[package]] name = "serde" -version = "1.0.116" +version = "1.0.117" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "96fe57af81d28386a513cbc6858332abc6117cfdb5999647c6444b8f43a370a5" +checksum = "b88fa983de7720629c9387e9f517353ed404164b1e482c970a90c1a4aaf7dc1a" dependencies = [ "serde_derive", ] [[package]] name = "serde_derive" -version = "1.0.116" +version = "1.0.117" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f630a6370fd8e457873b4bd2ffdae75408bc291ba72be773772a4c2a065d9ae8" +checksum = "cbd1ae72adb44aab48f325a02444a5fc079349a8d804c1fc922aed3f7454c74e" dependencies = [ "proc-macro2", "quote", @@ -992,9 +993,9 @@ dependencies = [ [[package]] name = "syn" -version = "1.0.44" +version = "1.0.45" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e03e57e4fcbfe7749842d53e24ccb9aa12b7252dbe5e91d2acad31834c8b8fdd" +checksum = "ea9c5432ff16d6152371f808fb5a871cd67368171b09bb21b43df8e4a47a3556" dependencies = [ "proc-macro2", "quote", diff --git a/helix-lsp/Cargo.toml b/helix-lsp/Cargo.toml index 1942fc24a..b34c139f0 100644 --- a/helix-lsp/Cargo.toml +++ b/helix-lsp/Cargo.toml @@ -7,6 +7,8 @@ edition = "2018" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] +helix-core = { path = "../helix-core" } + lsp-types = { version = "0.82", features = ["proposed"] } smol = "1.2" url = "2" diff --git a/helix-lsp/log b/helix-lsp/log new file mode 100644 index 000000000..d8370f16e --- /dev/null +++ b/helix-lsp/log @@ -0,0 +1,45 @@ +Sun Oct 18 21:15:33 2020:["lsp#register_server", "server registered", "typescript-language-server"] +Sun Oct 18 21:15:33 2020:["lsp#register_server", "server registered", "elixir-ls"] +Sun Oct 18 21:15:33 2020:["lsp#register_server", "server registered", "vue-language-server"] +Sun Oct 18 21:15:33 2020:["lsp#register_server", "server registered", "rust-analyzer"] +Sun Oct 18 21:15:33 2020:["s:on_text_document_did_open()", 1, "", "/Users/speed/src/helix/helix-lsp", ""] +Sun Oct 18 21:15:34 2020:["s:on_text_document_did_close()", 1] +Sun Oct 18 21:15:34 2020:["s:on_text_document_did_open()", 1, "rust", "/Users/speed/src/helix", "file:///Users/speed/src/helix/helix-lsp/src/lib.rs"] +Sun Oct 18 21:15:34 2020:["Starting server", "rust-analyzer", ["rust-analyzer"]] +Sun Oct 18 21:15:34 2020:[{"response": {"data": {"__data__": "vim-lsp", "lsp_id": 7, "server_name": "rust-analyzer"}, "message": "started lsp server successfully"}}] +Sun Oct 18 21:15:34 2020:["--->", 7, "rust-analyzer", {"method": "initialize", "params": {"rootUri": "file:///Users/speed/src/helix/helix-lsp", "capabilities": {"workspace": {"configuration": true, "applyEdit": true}, "textDocument": {"implementation": {"linkSupport": true}, "documentSymbol": {"symbolKind": {"valueSet": [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "hierarchicalDocumentSymbolSupport": false}, "semanticHighlightingCapabilities": {"semanticHighlighting": false}, "codeAction": {"codeActionLiteralSupport": {"codeActionKind": {"valueSet": ["", "quickfix", "refactor", "refactor.extract", "refactor.inline", "refactor.rewrite", "source", "source.organizeImports"]}}, "dynamicRegistration": false}, "completion": {"completionItem": {"snippetSupport": false, "documentationFormat": ["plaintext"]}, "completionItemKind": {"valueSet": [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 1, 2, 3, 4, 5, 6, 7, 8, 9]}}, "foldingRange": {"lineFoldingOnly": true}, "typeDefinition": {"linkSupport": true}, "typeHierarchy": false, "declaration": {"linkSupport": true}, "definition": {"linkSupport": true}}}, "rootPath": "/Users/speed/src/helix/helix-lsp", "processId": 22973, "trace": "off"}}] +Sun Oct 18 21:15:34 2020:["<---", 7, "rust-analyzer", {"response": {"id": 1, "jsonrpc": "2.0", "result": {"capabilities": {"documentHighlightProvider": true, "hoverProvider": true, "typeDefinitionProvider": true, "workspaceSymbolProvider": true, "referencesProvider": true, "signatureHelpProvider": {"triggerCharacters": ["(", ","]}, "foldingRangeProvider": true, "callHierarchyProvider": true, "codeActionProvider": {"codeActionKinds": ["", "quickfix", "refactor", "refactor.extract", "refactor.inline", "refactor.rewrite"]}, "textDocumentSync": {"save": {}, "change": 2, "openClose": true}, "codeLensProvider": {"resolveProvider": true}, "implementationProvider": true, "documentOnTypeFormattingProvider": {"moreTriggerCharacter": [".", ">"], "firstTriggerCharacter": "="}, "definitionProvider": true, "selectionRangeProvider": true, "semanticTokensProvider": {"legend": {"tokenTypes": ["comment", "keyword", "string", "number", "regexp", "operator", "namespace", "type", "struct", "class", "interface", "enum", "typeParameter", "function", "member", "property", "macro", "variable", "parameter", "label", "attribute", "boolean", "builtinType", "enumMember", "escapeSequence", "formatSpecifier", "generic", "lifetime", "punctuation", "selfKeyword", "typeAlias", "union", "unresolvedReference"], "tokenModifiers": ["documentation", "declaration", "definition", "static", "abstract", "deprecated", "readonly", "constant", "controlFlow", "injected", "mutable", "unsafe", "attribute"]}, "documentProvider": true, "rangeProvider": true}, "documentFormattingProvider": true, "documentSymbolProvider": true, "experimental": {"parentModule": true, "onEnter": true, "runnables": {"kinds": ["cargo"]}, "ssr": true, "joinLines": true}, "renameProvider": {"prepareProvider": true}, "completionProvider": {"triggerCharacters": [":", "."]}}, "serverInfo": {"version": "???????", "name": "rust-analyzer"}}}, "request": {"id": 1, "jsonrpc": "2.0", "method": "initialize", "params": {"rootUri": "file:///Users/speed/src/helix/helix-lsp", "capabilities": {"workspace": {"configuration": true, "applyEdit": true}, "textDocument": {"implementation": {"linkSupport": true}, "documentSymbol": {"symbolKind": {"valueSet": [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "hierarchicalDocumentSymbolSupport": false}, "semanticHighlightingCapabilities": {"semanticHighlighting": false}, "codeAction": {"codeActionLiteralSupport": {"codeActionKind": {"valueSet": ["", "quickfix", "refactor", "refactor.extract", "refactor.inline", "refactor.rewrite", "source", "source.organizeImports"]}}, "dynamicRegistration": false}, "completion": {"completionItem": {"snippetSupport": false, "documentationFormat": ["plaintext"]}, "completionItemKind": {"valueSet": [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 1, 2, 3, 4, 5, 6, 7, 8, 9]}}, "foldingRange": {"lineFoldingOnly": true}, "typeDefinition": {"linkSupport": true}, "typeHierarchy": false, "declaration": {"linkSupport": true}, "definition": {"linkSupport": true}}}, "rootPath": "/Users/speed/src/helix/helix-lsp", "processId": 22973, "trace": "off"}}}] +Sun Oct 18 21:15:34 2020:["--->", 7, "rust-analyzer", {"method": "initialized", "params": {}}] +Sun Oct 18 21:15:34 2020:[{"response": {"data": {"__data__": "vim-lsp", "server_name": "rust-analyzer"}, "message": "configuration sent"}}] +Sun Oct 18 21:15:34 2020:["s:update_file_content()", 1] +Sun Oct 18 21:15:34 2020:["--->", 7, "rust-analyzer", {"method": "textDocument/didOpen", "params": {"textDocument": {"uri": "file:///Users/speed/src/helix/helix-lsp/src/lib.rs", "version": 1, "languageId": "rust", "text": "use std::collections::HashMap;\n\nuse jsonrpc_core as jsonrpc;\nuse lsp_types as lsp;\n\nuse serde::{Deserialize, Serialize};\nuse serde_json::Value;\n\nuse smol::channel::{Receiver, Sender};\nuse smol::io::{BufReader, BufWriter};\nuse smol::prelude::*;\nuse smol::process::{Child, ChildStderr, ChildStdin, ChildStdout, Command, Stdio};\nuse smol::Executor;\n\nuse futures_util::{select, FutureExt};\n\n/// A type representing all possible values sent from the server to the client.\n#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]\n#[serde(deny_unknown_fields)]\n#[serde(untagged)]\nenum Message {\n /// A regular JSON-RPC request output (single response).\n Output(jsonrpc::Output),\n /// A notification.\n Notification(jsonrpc::Notification),\n /// A JSON-RPC request\n Call(jsonrpc::Call),\n}\n\npub struct Client {\n process: Child,\n stderr: BufReader,\n outgoing: Sender,\n\n pub request_counter: u64,\n\n capabilities: Option,\n}\n\nimpl Client {\n pub fn start(ex: &Executor, cmd: &str, args: &[String]) -> Self {\n let mut process = Command::new(cmd)\n .args(args)\n .stdin(Stdio::piped())\n .stdout(Stdio::piped())\n .stderr(Stdio::piped())\n .spawn()\n .expect(\"Failed to start language server\");\n // smol makes sure the process is reaped on drop, but using kill_on_drop(true) maybe?\n\n // TODO: do we need bufreader/writer here? or do we use async wrappers on unblock?\n let writer = BufWriter::new(process.stdin.take().expect(\"Failed to open stdin\"));\n let reader = BufReader::new(process.stdout.take().expect(\"Failed to open stdout\"));\n let stderr = BufReader::new(process.stderr.take().expect(\"Failed to open stderr\"));\n\n let (incoming, outgoing) = Transport::start(ex, reader, writer);\n\n Client {\n process,\n stderr,\n outgoing,\n\n request_counter: 0,\n\n capabilities: None,\n }\n }\n\n fn next_request_id(&mut self) -> jsonrpc::Id {\n let id = jsonrpc::Id::Num(self.request_counter);\n self.request_counter += 1;\n id\n }\n\n fn to_params(value: Value) -> anyhow::Result {\n use jsonrpc::Params;\n\n let params = match value {\n Value::Null => Params::None,\n Value::Bool(_) | Value::Number(_) | Value::String(_) => Params::Array(vec![value]),\n Value::Array(vec) => Params::Array(vec),\n Value::Object(map) => Params::Map(map),\n };\n\n Ok(params)\n }\n\n pub async fn request(\n &mut self,\n params: R::Params,\n ) -> anyhow::Result\n where\n R::Params: serde::Serialize,\n R::Result: core::fmt::Debug, // TODO: temporary\n {\n let params = serde_json::to_value(params)?;\n\n let request = jsonrpc::MethodCall {\n jsonrpc: Some(jsonrpc::Version::V2),\n id: self.next_request_id(),\n method: R::METHOD.to_string(),\n params: Self::to_params(params)?,\n };\n\n let (tx, rx) = smol::channel::bounded::>(1);\n\n self.outgoing\n .send(Payload::Request {\n chan: tx,\n value: request,\n })\n .await?;\n\n let response = rx.recv().await??;\n\n let response = serde_json::from_value(response)?;\n\n // TODO: we should pass request to a sender thread via a channel\n // so it can't be interleaved\n\n // TODO: responses can be out of order, we need to register a single shot response channel\n\n Ok(response)\n }\n\n pub async fn notify(\n &mut self,\n params: R::Params,\n ) -> anyhow::Result<()>\n where\n R::Params: serde::Serialize,\n {\n let params = serde_json::to_value(params)?;\n\n let notification = jsonrpc::Notification {\n jsonrpc: Some(jsonrpc::Version::V2),\n method: R::METHOD.to_string(),\n params: Self::to_params(params)?,\n };\n\n self.outgoing\n .send(Payload::Notification(notification))\n .await?;\n\n Ok(())\n }\n\n // -------------------------------------------------------------------------------------------\n // General messages\n // -------------------------------------------------------------------------------------------\n\n pub async fn initialize(&mut self) -> anyhow::Result<()> {\n // TODO: delay any requests that are triggered prior to initialize\n\n #[allow(deprecated)]\n let params = lsp::InitializeParams {\n process_id: Some(u64::from(std::process::id())),\n root_path: None,\n // root_uri: Some(lsp_types::Url::parse(\"file://localhost/\")?),\n root_uri: None, // set to project root in the future\n initialization_options: None,\n capabilities: lsp::ClientCapabilities::default(),\n trace: None,\n workspace_folders: None,\n client_info: None,\n };\n\n let response = self.request::(params).await?;\n self.capabilities = Some(response.capabilities);\n\n // next up, notify\n self.notify::(lsp::InitializedParams {})\n .await?;\n\n Ok(())\n }\n\n pub async fn shutdown(&mut self) -> anyhow::Result<()> {\n self.request::(()).await\n }\n\n pub async fn exit(&mut self) -> anyhow::Result<()> {\n self.notify::(()).await\n }\n\n // -------------------------------------------------------------------------------------------\n // Text document\n // -------------------------------------------------------------------------------------------\n\n pub async fn text_document_did_open(\n &mut self,\n state: &helix_core::State,\n ) -> anyhow::Result<()> {\n self.notify::(lsp::DidOpenTextDocumentParams {\n text_document: lsp::TextDocumentItem {\n uri: lsp::Url::from_file_path(\n std::fs::canonicalize(state.path.as_ref().unwrap()).unwrap(),\n )\n .unwrap(),\n language_id: \"rust\".to_string(), // TODO: hardcoded for now\n version: 0,\n text: String::from(&state.doc),\n },\n })\n .await\n }\n\n // TODO: trigger any time history.commit_revision happens\n pub async fn text_document_did_change(\n &mut self,\n state: &helix_core::State,\n ) -> anyhow::Result<()> {\n self.notify::(lsp::DidSaveTextDocumentParams {\n text_document: lsp::TextDocumentIdentifier::new(\n lsp::Url::from_file_path(state.path.as_ref().unwrap()).unwrap(),\n ),\n text: None, // TODO?\n })\n .await\n }\n\n pub async fn text_document_did_close(&mut self) -> anyhow::Result<()> {\n unimplemented!()\n }\n\n // will_save / will_save_wait_until\n\n pub async fn text_document_did_save(&mut self) -> anyhow::Result<()> {\n unimplemented!()\n }\n}\n\nenum Payload {\n Request {\n chan: Sender>,\n value: jsonrpc::MethodCall,\n },\n Notification(jsonrpc::Notification),\n}\n\nstruct Transport {\n incoming: Sender,\n outgoing: Receiver,\n\n pending_requests: HashMap>>,\n headers: HashMap,\n\n writer: BufWriter,\n reader: BufReader,\n}\n\nimpl Transport {\n pub fn start(\n ex: &Executor,\n reader: BufReader,\n writer: BufWriter,\n ) -> (Receiver, Sender) {\n let (incoming, rx) = smol::channel::unbounded();\n let (tx, outgoing) = smol::channel::unbounded();\n\n let transport = Self {\n reader,\n writer,\n incoming,\n outgoing,\n pending_requests: Default::default(),\n headers: Default::default(),\n };\n\n ex.spawn(transport.duplex()).detach();\n\n (rx, tx)\n }\n\n async fn recv(\n reader: &mut (impl AsyncBufRead + Unpin),\n headers: &mut HashMap,\n ) -> Result {\n // read headers\n loop {\n let mut header = String::new();\n // detect pipe closed if 0\n reader.read_line(&mut header).await?;\n let header = header.trim();\n\n if header.is_empty() {\n break;\n }\n\n let parts: Vec<&str> = header.split(\": \").collect();\n if parts.len() != 2 {\n // return Err(Error::new(ErrorKind::Other, \"Failed to parse header\"));\n panic!()\n }\n headers.insert(parts[0].to_string(), parts[1].to_string());\n }\n\n // find content-length\n let content_length = headers.get(\"Content-Length\").unwrap().parse().unwrap();\n\n let mut content = vec![0; content_length];\n reader.read_exact(&mut content).await?;\n let msg = String::from_utf8(content).unwrap();\n\n // read data\n\n // try parsing as output (server response) or call (server request)\n let output: serde_json::Result = serde_json::from_str(&msg);\n\n Ok(output?)\n }\n\n pub async fn send_payload(&mut self, payload: Payload) -> anyhow::Result<()> {\n match payload {\n Payload::Request { chan, value } => {\n self.pending_requests.insert(value.id.clone(), chan);\n\n let json = serde_json::to_string(&value)?;\n self.send(json).await\n }\n Payload::Notification(value) => {\n let json = serde_json::to_string(&value)?;\n self.send(json).await\n }\n }\n }\n\n pub async fn send(&mut self, request: String) -> anyhow::Result<()> {\n println!(\"-> {}\", request);\n\n // send the headers\n self.writer\n .write_all(format!(\"Content-Length: {}\\r\\n\\r\\n\", request.len()).as_bytes())\n .await?;\n\n // send the body\n self.writer.write_all(request.as_bytes()).await?;\n\n self.writer.flush().await?;\n\n Ok(())\n }\n\n pub async fn recv_response(&mut self, output: jsonrpc::Output) -> anyhow::Result<()> {\n match output {\n jsonrpc::Output::Success(jsonrpc::Success { id, result, .. }) => {\n println!(\"<- {}\", result);\n\n let tx = self\n .pending_requests\n .remove(&id)\n .expect(\"pending_request with id not found!\");\n tx.send(Ok(result)).await?;\n }\n jsonrpc::Output::Failure(_) => panic!(\"recv fail\"),\n msg => unimplemented!(\"{:?}\", msg),\n }\n Ok(())\n }\n\n pub async fn duplex(mut self) {\n loop {\n select! {\n // client -> server\n msg = self.outgoing.next().fuse() => {\n if msg.is_none() {\n break;\n }\n let msg = msg.unwrap();\n\n self.send_payload(msg).await.unwrap();\n }\n // server <- client\n msg = Self::recv(&mut self.reader, &mut self.headers).fuse() => {\n if msg.is_err() {\n break;\n }\n let msg = msg.unwrap();\n\n match msg {\n Message::Output(output) => self.recv_response(output).await.unwrap(),\n Message::Notification(_) => {\n // dispatch\n }\n Message::Call(_) => {\n // dispatch\n }\n };\n }\n }\n }\n }\n}\n"}}}] +Sun Oct 18 21:15:34 2020:[{"response": {"data": {"__data__": "vim-lsp", "server_name": "rust-analyzer"}, "message": "server already started"}}] +Sun Oct 18 21:15:34 2020:[{"response": {"data": {"__data__": "vim-lsp", "init_result": {"id": 1, "jsonrpc": "2.0", "result": {"capabilities": {"documentHighlightProvider": true, "hoverProvider": true, "typeDefinitionProvider": true, "workspaceSymbolProvider": true, "referencesProvider": true, "signatureHelpProvider": {"triggerCharacters": ["(", ","]}, "foldingRangeProvider": true, "callHierarchyProvider": true, "codeActionProvider": {"codeActionKinds": ["", "quickfix", "refactor", "refactor.extract", "refactor.inline", "refactor.rewrite"]}, "textDocumentSync": {"save": {}, "change": 2, "openClose": true}, "codeLensProvider": {"resolveProvider": true}, "implementationProvider": true, "documentOnTypeFormattingProvider": {"moreTriggerCharacter": [".", ">"], "firstTriggerCharacter": "="}, "definitionProvider": true, "selectionRangeProvider": true, "semanticTokensProvider": {"legend": {"tokenTypes": ["comment", "keyword", "string", "number", "regexp", "operator", "namespace", "type", "struct", "class", "interface", "enum", "typeParameter", "function", "member", "property", "macro", "variable", "parameter", "label", "attribute", "boolean", "builtinType", "enumMember", "escapeSequence", "formatSpecifier", "generic", "lifetime", "punctuation", "selfKeyword", "typeAlias", "union", "unresolvedReference"], "tokenModifiers": ["documentation", "declaration", "definition", "static", "abstract", "deprecated", "readonly", "constant", "controlFlow", "injected", "mutable", "unsafe", "attribute"]}, "documentProvider": true, "rangeProvider": true}, "documentFormattingProvider": true, "documentSymbolProvider": true, "experimental": {"parentModule": true, "onEnter": true, "runnables": {"kinds": ["cargo"]}, "ssr": true, "joinLines": true}, "renameProvider": {"prepareProvider": true}, "completionProvider": {"triggerCharacters": [":", "."]}}, "serverInfo": {"version": "???????", "name": "rust-analyzer"}}}, "server_name": "rust-analyzer"}, "message": "lsp server already initialized"}}] +Sun Oct 18 21:15:34 2020:[{"response": {"data": {"__data__": "vim-lsp", "server_name": "rust-analyzer"}, "message": "configuration sent"}}] +Sun Oct 18 21:15:34 2020:[{"response": {"data": {"path": "file:///Users/speed/src/helix/helix-lsp/src/lib.rs", "__data__": "vim-lsp", "server_name": "rust-analyzer"}, "message": "already opened"}}] +Sun Oct 18 21:15:34 2020:[{"response": {"data": {"path": "file:///Users/speed/src/helix/helix-lsp/src/lib.rs", "__data__": "vim-lsp", "server_name": "rust-analyzer"}, "message": "not dirty"}}] +Sun Oct 18 21:15:34 2020:["--->", 7, "rust-analyzer", {"method": "textDocument/foldingRange", "on_notification": "---funcref---", "bufnr": 1, "params": {"textDocument": {"uri": "file:///Users/speed/src/helix/helix-lsp/src/lib.rs"}}, "sync": 0}] +Sun Oct 18 21:15:34 2020:[{"response": {"data": {"path": "file:///Users/speed/src/helix/helix-lsp/src/lib.rs", "__data__": "vim-lsp", "filetype": "rust", "server_name": "rust-analyzer"}, "message": "textDocument/open sent"}}] +Sun Oct 18 21:15:34 2020:[{"response": {"data": {"path": "file:///Users/speed/src/helix/helix-lsp/src/lib.rs", "__data__": "vim-lsp", "server_name": "rust-analyzer"}, "message": "not dirty"}}] +Sun Oct 18 21:15:35 2020:["<---", 7, {"id": 0, "jsonrpc": "2.0", "method": "client/registerCapability", "params": {"registrations": [{"id": "textDocument/didSave", "registerOptions": {"includeText": false, "documentSelector": [{"pattern": "**/*.rs"}, {"pattern": "**/Cargo.toml"}, {"pattern": "**/Cargo.lock"}]}, "method": "textDocument/didSave"}]}}] +Sun Oct 18 21:15:35 2020:["--->", 7, "rust-analyzer", {"id": 0, "error": {"code": -32601, "message": "Method not found"}}] +Sun Oct 18 21:15:35 2020:["<---", 7, "rust-analyzer", {"response": {"id": 2, "jsonrpc": "2.0", "result": [{"startLine": 2, "kind": "imports", "endLine": 3}, {"startLine": 5, "kind": "imports", "endLine": 6}, {"startLine": 8, "kind": "imports", "endLine": 12}, {"startLine": 20, "endLine": 27}, {"startLine": 29, "endLine": 37}, {"startLine": 39, "endLine": 230}, {"startLine": 40, "endLine": 66}, {"startLine": 57, "endLine": 65}, {"startLine": 68, "endLine": 72}, {"startLine": 74, "endLine": 85}, {"startLine": 77, "endLine": 81}, {"startLine": 87, "endLine": 89}, {"startLine": 94, "endLine": 123}, {"startLine": 97, "endLine": 101}, {"startLine": 107, "endLine": 110}, {"startLine": 107, "endLine": 109}, {"startLine": 117, "kind": "comment", "endLine": 118}, {"startLine": 125, "endLine": 127}, {"startLine": 131, "endLine": 145}, {"startLine": 134, "endLine": 137}, {"startLine": 147, "kind": "comment", "endLine": 149}, {"startLine": 151, "endLine": 175}, {"startLine": 155, "endLine": 164}, {"startLine": 177, "endLine": 179}, {"startLine": 181, "endLine": 183}, {"startLine": 185, "kind": "comment", "endLine": 187}, {"startLine": 189, "endLine": 191}, {"startLine": 192, "endLine": 205}, {"startLine": 193, "endLine": 203}, {"startLine": 193, "endLine": 202}, {"startLine": 194, "endLine": 201}, {"startLine": 195, "endLine": 197}, {"startLine": 208, "endLine": 210}, {"startLine": 211, "endLine": 219}, {"startLine": 212, "endLine": 217}, {"startLine": 212, "endLine": 216}, {"startLine": 213, "endLine": 214}, {"startLine": 221, "endLine": 223}, {"startLine": 227, "endLine": 229}, {"startLine": 232, "endLine": 238}, {"startLine": 233, "endLine": 235}, {"startLine": 240, "endLine": 249}, {"startLine": 251, "endLine": 392}, {"startLine": 252, "endLine": 255}, {"startLine": 256, "endLine": 272}, {"startLine": 260, "endLine": 266}, {"startLine": 274, "endLine": 276}, {"startLine": 277, "endLine": 310}, {"startLine": 279, "endLine": 295}, {"startLine": 285, "endLine": 287}, {"startLine": 290, "endLine": 293}, {"startLine": 312, "endLine": 325}, {"startLine": 313, "endLine": 324}, {"startLine": 314, "endLine": 319}, {"startLine": 320, "endLine": 323}, {"startLine": 327, "endLine": 341}, {"startLine": 343, "endLine": 358}, {"startLine": 344, "endLine": 356}, {"startLine": 345, "endLine": 353}, {"startLine": 360, "endLine": 391}, {"startLine": 361, "endLine": 390}, {"startLine": 362, "endLine": 389}, {"startLine": 364, "endLine": 371}, {"startLine": 365, "endLine": 367}, {"startLine": 373, "endLine": 388}, {"startLine": 374, "endLine": 376}, {"startLine": 379, "endLine": 386}, {"startLine": 381, "endLine": 383}, {"startLine": 384, "endLine": 386}]}, "request": {"id": 2, "jsonrpc": "2.0", "method": "textDocument/foldingRange", "params": {"textDocument": {"uri": "file:///Users/speed/src/helix/helix-lsp/src/lib.rs"}}}}] +Sun Oct 18 21:15:36 2020:["<---", 7, "rust-analyzer", {"response": {"method": "textDocument/publishDiagnostics", "jsonrpc": "2.0", "params": {"diagnostics": [{"source": "rustc", "range": {"end": {"character": 15, "line": 355}, "start": {"character": 12, "line": 355}}, "code": "unreachable_patterns", "message": "unreachable pattern\n`#[warn(unreachable_patterns)]` on by default", "severity": 2}], "uri": "file:///Users/speed/src/helix/helix-lsp/src/lib.rs", "version": 1}}}] +Sun Oct 18 21:15:36 2020:["<---", 7, "rust-analyzer", {"response": {"method": "textDocument/publishDiagnostics", "jsonrpc": "2.0", "params": {"diagnostics": [{"source": "rustc", "tags": [1], "range": {"end": {"character": 28, "line": 618}, "start": {"character": 24, "line": 618}}, "code": "unused_variables", "message": "unused variable: `view`\n`#[warn(unused_variables)]` on by default", "severity": 2}], "uri": "file:///Users/speed/src/helix/helix-view/src/commands.rs"}}}] +Sun Oct 18 21:15:36 2020:["<---", 7, "rust-analyzer", {"response": {"method": "textDocument/publishDiagnostics", "jsonrpc": "2.0", "params": {"diagnostics": [{"source": "rustc", "range": {"end": {"character": 15, "line": 355}, "start": {"character": 12, "line": 355}}, "code": "unreachable_patterns", "message": "unreachable pattern\n`#[warn(unreachable_patterns)]` on by default", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 21, "line": 55}, "start": {"character": 13, "line": 55}}, "code": "unused_variables", "message": "unused variable: `incoming`\n`#[warn(unused_variables)]` on by default", "severity": 2}], "uri": "file:///Users/speed/src/helix/helix-lsp/src/lib.rs", "version": 1}}}] +Sun Oct 18 21:15:36 2020:["<---", 7, "rust-analyzer", {"response": {"method": "textDocument/publishDiagnostics", "jsonrpc": "2.0", "params": {"diagnostics": [{"source": "rustc", "range": {"end": {"character": 15, "line": 355}, "start": {"character": 12, "line": 355}}, "code": "unreachable_patterns", "message": "unreachable pattern\n`#[warn(unreachable_patterns)]` on by default", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 21, "line": 55}, "start": {"character": 13, "line": 55}}, "code": "unused_variables", "message": "unused variable: `incoming`\n`#[warn(unused_variables)]` on by default", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 18, "line": 30}, "start": {"character": 4, "line": 30}}, "code": "dead_code", "message": "field is never read: `process`\n`#[warn(dead_code)]` on by default", "severity": 2}], "uri": "file:///Users/speed/src/helix/helix-lsp/src/lib.rs", "version": 1}}}] +Sun Oct 18 21:15:36 2020:["<---", 7, "rust-analyzer", {"response": {"method": "textDocument/publishDiagnostics", "jsonrpc": "2.0", "params": {"diagnostics": [{"source": "rustc", "range": {"end": {"character": 15, "line": 355}, "start": {"character": 12, "line": 355}}, "code": "unreachable_patterns", "message": "unreachable pattern\n`#[warn(unreachable_patterns)]` on by default", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 21, "line": 55}, "start": {"character": 13, "line": 55}}, "code": "unused_variables", "message": "unused variable: `incoming`\n`#[warn(unused_variables)]` on by default", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 18, "line": 30}, "start": {"character": 4, "line": 30}}, "code": "dead_code", "message": "field is never read: `process`\n`#[warn(dead_code)]` on by default", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 34, "line": 31}, "start": {"character": 4, "line": 31}}, "code": "dead_code", "message": "field is never read: `stderr`", "severity": 2}], "uri": "file:///Users/speed/src/helix/helix-lsp/src/lib.rs", "version": 1}}}] +Sun Oct 18 21:15:36 2020:["<---", 7, "rust-analyzer", {"response": {"method": "textDocument/publishDiagnostics", "jsonrpc": "2.0", "params": {"diagnostics": [{"source": "rustc", "range": {"end": {"character": 15, "line": 355}, "start": {"character": 12, "line": 355}}, "code": "unreachable_patterns", "message": "unreachable pattern\n`#[warn(unreachable_patterns)]` on by default", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 21, "line": 55}, "start": {"character": 13, "line": 55}}, "code": "unused_variables", "message": "unused variable: `incoming`\n`#[warn(unused_variables)]` on by default", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 18, "line": 30}, "start": {"character": 4, "line": 30}}, "code": "dead_code", "message": "field is never read: `process`\n`#[warn(dead_code)]` on by default", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 34, "line": 31}, "start": {"character": 4, "line": 31}}, "code": "dead_code", "message": "field is never read: `stderr`", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 29, "line": 241}, "start": {"character": 4, "line": 241}}, "code": "dead_code", "message": "field is never read: `incoming`", "severity": 2}], "uri": "file:///Users/speed/src/helix/helix-lsp/src/lib.rs", "version": 1}}}] +Sun Oct 18 21:15:39 2020:["lsp#register_server", "server registered", "typescript-language-server"] +Sun Oct 18 21:15:39 2020:["lsp#register_server", "server registered", "elixir-ls"] +Sun Oct 18 21:15:39 2020:["lsp#register_server", "server registered", "vue-language-server"] +Sun Oct 18 21:15:39 2020:["lsp#register_server", "server registered", "rust-analyzer"] +Sun Oct 18 21:15:39 2020:["s:on_text_document_did_open()", 1, "vim", "/Users/speed/src/helix/helix-lsp", "file:///Users/speed/.vimrc"] +Sun Oct 18 21:15:40 2020:["s:on_text_document_did_change()", 1] +Sun Oct 18 21:15:40 2020:["s:send_didchange_queue() will be triggered"] +Sun Oct 18 21:15:40 2020:["s:on_text_document_did_change()", 1] +Sun Oct 18 21:15:41 2020:["s:on_text_document_did_save()", 1] +Sun Oct 18 21:15:41 2020:["s:on_text_document_did_close()", 1] +Sun Oct 18 21:15:55 2020:["<---", 7, "rust-analyzer", {"response": {"method": "textDocument/publishDiagnostics", "jsonrpc": "2.0", "params": {"diagnostics": [{"source": "rustc", "range": {"end": {"character": 15, "line": 355}, "start": {"character": 12, "line": 355}}, "code": "unreachable_patterns", "message": "unreachable pattern\n`#[warn(unreachable_patterns)]` on by default", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 21, "line": 55}, "start": {"character": 13, "line": 55}}, "code": "unused_variables", "message": "unused variable: `incoming`\n`#[warn(unused_variables)]` on by default", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 18, "line": 30}, "start": {"character": 4, "line": 30}}, "code": "dead_code", "message": "field is never read: `process`\n`#[warn(dead_code)]` on by default", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 34, "line": 31}, "start": {"character": 4, "line": 31}}, "code": "dead_code", "message": "field is never read: `stderr`", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 29, "line": 241}, "start": {"character": 4, "line": 241}}, "code": "dead_code", "message": "field is never read: `incoming`", "severity": 2}], "uri": "file:///Users/speed/src/helix/helix-lsp/src/lib.rs", "version": 1}}}] +Sun Oct 18 21:15:57 2020:["s:on_text_document_did_close()", 1] +Sun Oct 18 21:15:57 2020:["s:on_exit", 7, "rust-analyzer", "exited", 143] diff --git a/helix-lsp/src/lib.rs b/helix-lsp/src/lib.rs index b371f3376..41b3fdb2d 100644 --- a/helix-lsp/src/lib.rs +++ b/helix-lsp/src/lib.rs @@ -1,18 +1,22 @@ +mod transport; + +use transport::{Payload, Transport}; + use std::collections::HashMap; use jsonrpc_core as jsonrpc; use lsp_types as lsp; +use serde_json::Value; use serde::{Deserialize, Serialize}; -use serde_json::Value; -use smol::channel::{Receiver, Sender}; -use smol::io::{BufReader, BufWriter}; use smol::prelude::*; -use smol::process::{Child, ChildStderr, ChildStdin, ChildStdout, Command, Stdio}; -use smol::Executor; - -use futures_util::{select, FutureExt}; +use smol::{ + channel::{Receiver, Sender}, + io::{BufReader, BufWriter}, + process::{Child, ChildStderr, Command, Stdio}, + Executor, +}; /// A type representing all possible values sent from the server to the client. #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] @@ -27,14 +31,40 @@ enum Message { Call(jsonrpc::Call), } +#[derive(Debug, PartialEq, Clone)] +enum Notification {} + +impl Notification { + pub fn parse(method: &str, params: jsonrpc::Params) { + use lsp::notification::Notification as _; + + match method { + lsp::notification::PublishDiagnostics::METHOD => { + let params: lsp::PublishDiagnosticsParams = params + .parse() + .expect("Failed to parse PublishDiagnostics params"); + + println!("{:?}", params); + + // TODO: need to loop over diagnostics and distinguish them by URI + } + _ => println!("unhandled notification: {}", method), + } + } +} + pub struct Client { process: Child, stderr: BufReader, + outgoing: Sender, + incoming: Receiver, pub request_counter: u64, capabilities: Option, + // TODO: handle PublishDiagnostics Version + diagnostics: HashMap>, } impl Client { @@ -58,11 +88,14 @@ impl Client { Client { process, stderr, + outgoing, + incoming, request_counter: 0, capabilities: None, + diagnostics: HashMap::new(), } } @@ -187,191 +220,45 @@ impl Client { // Text document // ------------------------------------------------------------------------------------------- - pub async fn text_document_did_open(&mut self) -> anyhow::Result<()> { + pub async fn text_document_did_open( + &mut self, + state: &helix_core::State, + ) -> anyhow::Result<()> { self.notify::(lsp::DidOpenTextDocumentParams { text_document: lsp::TextDocumentItem { - uri: lsp::Url::parse(".")?, - language_id: "rust".to_string(), + uri: lsp::Url::from_file_path( + std::fs::canonicalize(state.path.as_ref().unwrap()).unwrap(), + ) + .unwrap(), + language_id: "rust".to_string(), // TODO: hardcoded for now version: 0, - text: "".to_string(), + text: String::from(&state.doc), }, }) .await } - pub async fn text_document_did_change(&mut self) -> anyhow::Result<()> { - unimplemented!() - } - - // will_save / will_save_wait_until - - pub async fn text_document_did_save(&mut self) -> anyhow::Result<()> { - unimplemented!() + // TODO: trigger any time history.commit_revision happens + pub async fn text_document_did_change( + &mut self, + state: &helix_core::State, + ) -> anyhow::Result<()> { + self.notify::(lsp::DidSaveTextDocumentParams { + text_document: lsp::TextDocumentIdentifier::new( + lsp::Url::from_file_path(state.path.as_ref().unwrap()).unwrap(), + ), + text: None, // TODO? + }) + .await } pub async fn text_document_did_close(&mut self) -> anyhow::Result<()> { unimplemented!() } -} - -enum Payload { - Request { - chan: Sender>, - value: jsonrpc::MethodCall, - }, - Notification(jsonrpc::Notification), -} - -struct Transport { - incoming: Sender, - outgoing: Receiver, - - pending_requests: HashMap>>, - headers: HashMap, - - writer: BufWriter, - reader: BufReader, -} - -impl Transport { - pub fn start( - ex: &Executor, - reader: BufReader, - writer: BufWriter, - ) -> (Receiver, Sender) { - let (incoming, rx) = smol::channel::unbounded(); - let (tx, outgoing) = smol::channel::unbounded(); - - let transport = Self { - reader, - writer, - incoming, - outgoing, - pending_requests: Default::default(), - headers: Default::default(), - }; - - ex.spawn(transport.duplex()).detach(); - - (rx, tx) - } - - async fn recv( - reader: &mut (impl AsyncBufRead + Unpin), - headers: &mut HashMap, - ) -> Result { - // read headers - loop { - let mut header = String::new(); - // detect pipe closed if 0 - reader.read_line(&mut header).await?; - let header = header.trim(); - - if header.is_empty() { - break; - } - - let parts: Vec<&str> = header.split(": ").collect(); - if parts.len() != 2 { - // return Err(Error::new(ErrorKind::Other, "Failed to parse header")); - panic!() - } - headers.insert(parts[0].to_string(), parts[1].to_string()); - } - - // find content-length - let content_length = headers.get("Content-Length").unwrap().parse().unwrap(); - - let mut content = vec![0; content_length]; - reader.read_exact(&mut content).await?; - let msg = String::from_utf8(content).unwrap(); - - // read data - - // try parsing as output (server response) or call (server request) - let output: serde_json::Result = serde_json::from_str(&msg); - - Ok(output?) - } - pub async fn send_payload(&mut self, payload: Payload) -> anyhow::Result<()> { - match payload { - Payload::Request { chan, value } => { - self.pending_requests.insert(value.id.clone(), chan); - - let json = serde_json::to_string(&value)?; - self.send(json).await - } - Payload::Notification(value) => { - let json = serde_json::to_string(&value)?; - self.send(json).await - } - } - } - - pub async fn send(&mut self, request: String) -> anyhow::Result<()> { - println!("-> {}", request); - - // send the headers - self.writer - .write_all(format!("Content-Length: {}\r\n\r\n", request.len()).as_bytes()) - .await?; - - // send the body - self.writer.write_all(request.as_bytes()).await?; - - self.writer.flush().await?; - - Ok(()) - } - - pub async fn recv_response(&mut self, output: jsonrpc::Output) -> anyhow::Result<()> { - match output { - jsonrpc::Output::Success(jsonrpc::Success { id, result, .. }) => { - println!("<- {}", result); - - let tx = self - .pending_requests - .remove(&id) - .expect("pending_request with id not found!"); - tx.send(Ok(result)).await?; - } - jsonrpc::Output::Failure(_) => panic!("recv fail"), - msg => unimplemented!("{:?}", msg), - } - Ok(()) - } + // will_save / will_save_wait_until - pub async fn duplex(mut self) { - loop { - select! { - // client -> server - msg = self.outgoing.next().fuse() => { - if msg.is_none() { - break; - } - let msg = msg.unwrap(); - - self.send_payload(msg).await.unwrap(); - } - // server <- client - msg = Self::recv(&mut self.reader, &mut self.headers).fuse() => { - if msg.is_err() { - break; - } - let msg = msg.unwrap(); - - match msg { - Message::Output(output) => self.recv_response(output).await.unwrap(), - Message::Notification(_) => { - // dispatch - } - Message::Call(_) => { - // dispatch - } - }; - } - } - } + pub async fn text_document_did_save(&mut self) -> anyhow::Result<()> { + unimplemented!() } } diff --git a/helix-lsp/src/transport.rs b/helix-lsp/src/transport.rs new file mode 100644 index 000000000..c44ffa918 --- /dev/null +++ b/helix-lsp/src/transport.rs @@ -0,0 +1,189 @@ +use std::collections::HashMap; + +use crate::{Message, Notification}; + +use jsonrpc_core as jsonrpc; +use lsp_types as lsp; +use serde_json::Value; + +use smol::prelude::*; + +use smol::{ + channel::{Receiver, Sender}, + io::{BufReader, BufWriter}, + process::{ChildStderr, ChildStdin, ChildStdout}, + Executor, +}; + +pub(crate) enum Payload { + Request { + chan: Sender>, + value: jsonrpc::MethodCall, + }, + Notification(jsonrpc::Notification), +} + +pub(crate) struct Transport { + incoming: Sender, + outgoing: Receiver, + + pending_requests: HashMap>>, + headers: HashMap, + + writer: BufWriter, + reader: BufReader, +} + +impl Transport { + pub fn start( + ex: &Executor, + reader: BufReader, + writer: BufWriter, + ) -> (Receiver, Sender) { + let (incoming, rx) = smol::channel::unbounded(); + let (tx, outgoing) = smol::channel::unbounded(); + + let transport = Self { + reader, + writer, + incoming, + outgoing, + pending_requests: Default::default(), + headers: Default::default(), + }; + + ex.spawn(transport.duplex()).detach(); + + (rx, tx) + } + + async fn recv( + reader: &mut (impl AsyncBufRead + Unpin), + headers: &mut HashMap, + ) -> Result { + // read headers + loop { + let mut header = String::new(); + // detect pipe closed if 0 + reader.read_line(&mut header).await?; + let header = header.trim(); + + if header.is_empty() { + break; + } + + let parts: Vec<&str> = header.split(": ").collect(); + if parts.len() != 2 { + // return Err(Error::new(ErrorKind::Other, "Failed to parse header")); + panic!() + } + headers.insert(parts[0].to_string(), parts[1].to_string()); + } + + // find content-length + let content_length = headers.get("Content-Length").unwrap().parse().unwrap(); + + let mut content = vec![0; content_length]; + reader.read_exact(&mut content).await?; + let msg = String::from_utf8(content).unwrap(); + + // read data + + // try parsing as output (server response) or call (server request) + let output: serde_json::Result = serde_json::from_str(&msg); + + Ok(output?) + } + + pub async fn send_payload(&mut self, payload: Payload) -> anyhow::Result<()> { + match payload { + Payload::Request { chan, value } => { + self.pending_requests.insert(value.id.clone(), chan); + + let json = serde_json::to_string(&value)?; + self.send(json).await + } + Payload::Notification(value) => { + let json = serde_json::to_string(&value)?; + self.send(json).await + } + } + } + + pub async fn send(&mut self, request: String) -> anyhow::Result<()> { + println!("-> {}", request); + + // send the headers + self.writer + .write_all(format!("Content-Length: {}\r\n\r\n", request.len()).as_bytes()) + .await?; + + // send the body + self.writer.write_all(request.as_bytes()).await?; + + self.writer.flush().await?; + + Ok(()) + } + + pub async fn recv_msg(&mut self, msg: Message) -> anyhow::Result<()> { + match msg { + Message::Output(output) => self.recv_response(output).await?, + Message::Notification(jsonrpc::Notification { method, params, .. }) => { + let notification = Notification::parse(&method, params); + + println!("<- {} {:?}", method, notification); + // dispatch + } + Message::Call(call) => { + println!("<- {:?}", call); + // dispatch + } + _ => unreachable!(), + }; + Ok(()) + } + + pub async fn recv_response(&mut self, output: jsonrpc::Output) -> anyhow::Result<()> { + match output { + jsonrpc::Output::Success(jsonrpc::Success { id, result, .. }) => { + println!("<- {}", result); + + let tx = self + .pending_requests + .remove(&id) + .expect("pending_request with id not found!"); + tx.send(Ok(result)).await?; + } + jsonrpc::Output::Failure(_) => panic!("recv fail"), + msg => unimplemented!("{:?}", msg), + } + Ok(()) + } + + pub async fn duplex(mut self) { + use futures_util::{select, FutureExt}; + loop { + select! { + // client -> server + msg = self.outgoing.next().fuse() => { + if msg.is_none() { + break; + } + let msg = msg.unwrap(); + + self.send_payload(msg).await.unwrap(); + } + // server <- client + msg = Self::recv(&mut self.reader, &mut self.headers).fuse() => { + if msg.is_err() { + break; + } + let msg = msg.unwrap(); + + self.recv_msg(msg).await.unwrap(); + } + } + } + } +} diff --git a/helix-term/src/main.rs b/helix-term/src/main.rs index c35c84d21..07f1ffffa 100644 --- a/helix-term/src/main.rs +++ b/helix-term/src/main.rs @@ -30,9 +30,11 @@ fn main() -> Result<(), Error> { smol::block_on(async { let res = lsp.initialize().await; - // Application::new(args).unwrap().run().await; - + let state = helix_core::State::load("test.rs".into(), &[]).unwrap(); + let res = lsp.text_document_did_open(&state).await; loop {} + + // Application::new(args).unwrap().run().await; }); Ok(()) From b2b3083a623ec3dc5e2d1ea9c6ba35970efe19a3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Hrastnik?= Date: Mon, 19 Oct 2020 16:20:59 +0900 Subject: [PATCH 04/23] Support multiple open views. --- helix-term/src/application.rs | 13 +++++-------- helix-view/src/editor.rs | 18 +++++++++++++++--- 2 files changed, 20 insertions(+), 11 deletions(-) diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs index 1e719f5f9..9c90b6f38 100644 --- a/helix-term/src/application.rs +++ b/helix-term/src/application.rs @@ -354,7 +354,7 @@ impl Application { fn render(&mut self) { let viewport = Rect::new(OFFSET, 0, self.terminal.size.0, self.terminal.size.1 - 2); // - 2 for statusline and prompt - if let Some(view) = &mut self.editor.view { + if let Some(view) = self.editor.view_mut() { self.terminal.render_view(view, viewport); if let Some(prompt) = &self.prompt { if prompt.should_close { @@ -368,11 +368,8 @@ impl Application { self.terminal.draw(); // TODO: drop unwrap - self.terminal.render_cursor( - self.editor.view.as_ref().unwrap(), - self.prompt.as_ref(), - viewport, - ); + self.terminal + .render_cursor(self.editor.view().unwrap(), self.prompt.as_ref(), viewport); } pub async fn event_loop(&mut self) { @@ -392,7 +389,7 @@ impl Application { self.terminal.resize(width, height); // TODO: simplistic ensure cursor in view for now - if let Some(view) = &mut self.editor.view { + if let Some(view) = self.editor.view_mut() { view.size = self.terminal.size; view.ensure_cursor_in_view() }; @@ -408,7 +405,7 @@ impl Application { .handle_input(event, &mut self.editor); self.render(); - } else if let Some(view) = &mut self.editor.view { + } else if let Some(view) = self.editor.view_mut() { let keys = vec![event]; // TODO: sequences (`gg`) // TODO: handle count other than 1 diff --git a/helix-view/src/editor.rs b/helix-view/src/editor.rs index c292caed3..08fd1f0c1 100644 --- a/helix-view/src/editor.rs +++ b/helix-view/src/editor.rs @@ -5,20 +5,32 @@ use std::path::PathBuf; use anyhow::Error; pub struct Editor { - pub view: Option, + pub views: Vec, + pub focus: usize, pub should_close: bool, } impl Editor { pub fn new() -> Self { Self { - view: None, + views: Vec::new(), + focus: 0, should_close: false, } } pub fn open(&mut self, path: PathBuf, size: (u16, u16)) -> Result<(), Error> { - self.view = Some(View::open(path, size)?); + let pos = self.views.len(); + self.views.push(View::open(path, size)?); + self.focus = pos; Ok(()) } + + pub fn view(&self) -> Option<&View> { + self.views.get(self.focus) + } + + pub fn view_mut(&mut self) -> Option<&mut View> { + self.views.get_mut(self.focus) + } } From 64b5b23315f12125a2c5b2f810fe5ac285bdfa79 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Hrastnik?= Date: Mon, 19 Oct 2020 17:18:03 +0900 Subject: [PATCH 05/23] Move theme from view to editor, support multiple views in editor. --- helix-core/src/state.rs | 2 +- helix-term/src/application.rs | 30 ++++++++++++++++-------------- helix-view/src/editor.rs | 9 ++++++++- helix-view/src/lib.rs | 1 + helix-view/src/view.rs | 16 +++++++--------- 5 files changed, 33 insertions(+), 25 deletions(-) diff --git a/helix-core/src/state.rs b/helix-core/src/state.rs index 1b0a67aef..35e20aef5 100644 --- a/helix-core/src/state.rs +++ b/helix-core/src/state.rs @@ -23,7 +23,7 @@ pub struct State { pub restore_cursor: bool, - // + // TODO: move these to a Document wrapper? pub syntax: Option, /// Pending changes since last history commit. pub changes: ChangeSet, diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs index 9c90b6f38..d65e7e2e3 100644 --- a/helix-term/src/application.rs +++ b/helix-term/src/application.rs @@ -1,6 +1,6 @@ use clap::ArgMatches as Args; use helix_core::{indent::TAB_WIDTH, state::Mode, syntax::HighlightEvent, Position, Range, State}; -use helix_view::{commands, keymap, prompt::Prompt, Editor, View}; +use helix_view::{commands, keymap, prompt::Prompt, Editor, Theme, View}; use std::{ borrow::Cow, @@ -15,8 +15,7 @@ use anyhow::Error; use crossterm::{ cursor, - cursor::position, - event::{self, read, Event, EventStream, KeyCode, KeyEvent}, + event::{read, Event, EventStream, KeyCode, KeyEvent}, execute, queue, terminal::{self, disable_raw_mode, enable_raw_mode}, }; @@ -75,19 +74,18 @@ impl Renderer { self.cache = Surface::empty(area); } - pub fn render_view(&mut self, view: &mut View, viewport: Rect) { - self.render_buffer(view, viewport); - self.render_statusline(view); + pub fn render_view(&mut self, view: &mut View, viewport: Rect, theme: &Theme) { + self.render_buffer(view, viewport, theme); + self.render_statusline(view, theme); } // TODO: ideally not &mut View but highlights require it because of cursor cache - pub fn render_buffer(&mut self, view: &mut View, viewport: Rect) { + pub fn render_buffer(&mut self, view: &mut View, viewport: Rect, theme: &Theme) { let area = Rect::new(0, 0, self.size.0, self.size.1); self.surface.reset(); // reset is faster than allocating new empty surface // clear with background color - self.surface - .set_style(area, view.theme.get("ui.background")); + self.surface.set_style(area, theme.get("ui.background")); // TODO: inefficient, should feed chunks.iter() to tree_sitter.parse_with(|offset, pos|) let source_code = view.state.doc().to_string(); @@ -150,7 +148,7 @@ impl Renderer { use helix_core::graphemes::{grapheme_width, RopeGraphemes}; let style = match spans.first() { - Some(span) => view.theme.get(view.theme.scopes()[span.0].as_str()), + Some(span) => theme.get(theme.scopes()[span.0].as_str()), None => Style::default().fg(Color::Rgb(164, 160, 232)), // lavender }; @@ -214,7 +212,7 @@ impl Renderer { } } } - let style: Style = view.theme.get("ui.linenr"); + let style: Style = theme.get("ui.linenr"); let last_line = view.last_line(); for (i, line) in (view.first_line..last_line).enumerate() { self.surface @@ -222,7 +220,7 @@ impl Renderer { } } - pub fn render_statusline(&mut self, view: &View) { + pub fn render_statusline(&mut self, view: &View, theme: &Theme) { let mode = match view.state.mode() { Mode::Insert => "INS", Mode::Normal => "NOR", @@ -231,7 +229,7 @@ impl Renderer { // statusline self.surface.set_style( Rect::new(0, self.size.1 - 2, self.size.0, 1), - view.theme.get("ui.statusline"), + theme.get("ui.statusline"), ); self.surface .set_string(1, self.size.1 - 2, mode, self.text_color); @@ -354,8 +352,11 @@ impl Application { fn render(&mut self) { let viewport = Rect::new(OFFSET, 0, self.terminal.size.0, self.terminal.size.1 - 2); // - 2 for statusline and prompt + // SAFETY: we cheat around the view_mut() borrow because it doesn't allow us to also borrow + // theme. Theme is immutable mutating view won't disrupt theme_ref. + let theme_ref = unsafe { &*(&self.editor.theme as *const Theme) }; if let Some(view) = self.editor.view_mut() { - self.terminal.render_view(view, viewport); + self.terminal.render_view(view, viewport, theme_ref); if let Some(prompt) = &self.prompt { if prompt.should_close { self.prompt = None; @@ -389,6 +390,7 @@ impl Application { self.terminal.resize(width, height); // TODO: simplistic ensure cursor in view for now + // TODO: loop over views if let Some(view) = self.editor.view_mut() { view.size = self.terminal.size; view.ensure_cursor_in_view() diff --git a/helix-view/src/editor.rs b/helix-view/src/editor.rs index 08fd1f0c1..61abd4829 100644 --- a/helix-view/src/editor.rs +++ b/helix-view/src/editor.rs @@ -1,4 +1,6 @@ +use crate::theme::Theme; use crate::View; +use helix_core::State; use std::path::PathBuf; @@ -8,20 +10,25 @@ pub struct Editor { pub views: Vec, pub focus: usize, pub should_close: bool, + pub theme: Theme, // TODO: share one instance } impl Editor { pub fn new() -> Self { + let theme = Theme::default(); + Self { views: Vec::new(), focus: 0, should_close: false, + theme, } } pub fn open(&mut self, path: PathBuf, size: (u16, u16)) -> Result<(), Error> { let pos = self.views.len(); - self.views.push(View::open(path, size)?); + let state = State::load(path, self.theme.scopes())?; + self.views.push(View::new(state, size)?); self.focus = pos; Ok(()) } diff --git a/helix-view/src/lib.rs b/helix-view/src/lib.rs index 8ea634af7..9abe8a1aa 100644 --- a/helix-view/src/lib.rs +++ b/helix-view/src/lib.rs @@ -6,4 +6,5 @@ pub mod theme; pub mod view; pub use editor::Editor; +pub use theme::Theme; pub use view::View; diff --git a/helix-view/src/view.rs b/helix-view/src/view.rs index 2b68dbc3f..d2a7d5562 100644 --- a/helix-view/src/view.rs +++ b/helix-view/src/view.rs @@ -1,8 +1,7 @@ use anyhow::Error; -use std::{borrow::Cow, path::PathBuf}; +use std::borrow::Cow; -use crate::theme::Theme; use helix_core::{ graphemes::{grapheme_width, RopeGraphemes}, indent::TAB_WIDTH, @@ -12,24 +11,23 @@ use tui::layout::Rect; pub const PADDING: usize = 5; +// TODO: view should be View { doc: Document(state, history,..) } +// since we can have multiple views into the same file pub struct View { pub state: State, - pub history: History, pub first_line: usize, pub size: (u16, u16), - pub theme: Theme, // TODO: share one instance + + // TODO: Doc<> fields + pub history: History, } impl View { - pub fn open(path: PathBuf, size: (u16, u16)) -> Result { - let theme = Theme::default(); - let state = State::load(path, theme.scopes())?; - + pub fn new(state: State, size: (u16, u16)) -> Result { let view = Self { state, first_line: 0, size, - theme, history: History::default(), }; From f9bfba4d96f80eb41beb91702558f6f165a0e70f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Hrastnik?= Date: Tue, 20 Oct 2020 13:58:34 +0900 Subject: [PATCH 06/23] Reroute LSP notification events into the main app event loop. --- Cargo.lock | 1 + helix-core/src/diagnostic.rs | 1 + helix-core/src/lib.rs | 2 + helix-core/src/state.rs | 10 +- helix-lsp/src/lib.rs | 33 ++-- helix-lsp/src/transport.rs | 14 +- helix-term/Cargo.toml | 2 + helix-term/src/application.rs | 281 ++++++++++++++++++++-------------- helix-term/src/main.rs | 12 +- helix-view/src/keymap.rs | 4 +- helix-view/src/view.rs | 2 +- 11 files changed, 207 insertions(+), 155 deletions(-) create mode 100644 helix-core/src/diagnostic.rs diff --git a/Cargo.lock b/Cargo.lock index c4beee76a..2e329fd1c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -472,6 +472,7 @@ dependencies = [ "anyhow", "clap", "crossterm", + "futures-util", "helix-core", "helix-lsp", "helix-view", diff --git a/helix-core/src/diagnostic.rs b/helix-core/src/diagnostic.rs new file mode 100644 index 000000000..aee648aa4 --- /dev/null +++ b/helix-core/src/diagnostic.rs @@ -0,0 +1 @@ +pub struct Diagnostic {} diff --git a/helix-core/src/lib.rs b/helix-core/src/lib.rs index 62d23a109..8458c36f7 100644 --- a/helix-core/src/lib.rs +++ b/helix-core/src/lib.rs @@ -1,4 +1,5 @@ #![allow(unused)] +mod diagnostic; pub mod graphemes; mod history; pub mod indent; @@ -22,6 +23,7 @@ pub use selection::Range; pub use selection::Selection; pub use syntax::Syntax; +pub use diagnostic::Diagnostic; pub use history::History; pub use state::State; diff --git a/helix-core/src/state.rs b/helix-core/src/state.rs index 35e20aef5..0f94f696f 100644 --- a/helix-core/src/state.rs +++ b/helix-core/src/state.rs @@ -1,6 +1,6 @@ use crate::graphemes::{nth_next_grapheme_boundary, nth_prev_grapheme_boundary, RopeGraphemes}; use crate::syntax::LOADER; -use crate::{ChangeSet, Position, Range, Rope, RopeSlice, Selection, Syntax}; +use crate::{ChangeSet, Diagnostic, Position, Range, Rope, RopeSlice, Selection, Syntax}; use anyhow::Error; use std::path::PathBuf; @@ -28,6 +28,8 @@ pub struct State { /// Pending changes since last history commit. pub changes: ChangeSet, pub old_state: Option<(Rope, Selection)>, + + pub diagnostics: Vec, } #[derive(Copy, Clone, PartialEq, Eq)] @@ -58,12 +60,13 @@ impl State { syntax: None, changes, old_state, + diagnostics: Vec::new(), } } // TODO: passing scopes here is awkward pub fn load(path: PathBuf, scopes: &[String]) -> Result { - use std::{env, fs::File, io::BufReader, path::PathBuf}; + use std::{env, fs::File, io::BufReader}; let _current_dir = env::current_dir()?; let doc = Rope::from_reader(BufReader::new(File::open(path.clone())?))?; @@ -81,7 +84,8 @@ impl State { state.syntax = Some(syntax); }; - state.path = Some(path); + // canonicalize path to absolute value + state.path = Some(std::fs::canonicalize(path)?); Ok(state) } diff --git a/helix-lsp/src/lib.rs b/helix-lsp/src/lib.rs index 41b3fdb2d..3598a5943 100644 --- a/helix-lsp/src/lib.rs +++ b/helix-lsp/src/lib.rs @@ -2,7 +2,7 @@ mod transport; use transport::{Payload, Transport}; -use std::collections::HashMap; +// use std::collections::HashMap; use jsonrpc_core as jsonrpc; use lsp_types as lsp; @@ -32,10 +32,12 @@ enum Message { } #[derive(Debug, PartialEq, Clone)] -enum Notification {} +pub enum Notification { + PublishDiagnostics(lsp::PublishDiagnosticsParams), +} impl Notification { - pub fn parse(method: &str, params: jsonrpc::Params) { + pub fn parse(method: &str, params: jsonrpc::Params) -> Notification { use lsp::notification::Notification as _; match method { @@ -44,11 +46,10 @@ impl Notification { .parse() .expect("Failed to parse PublishDiagnostics params"); - println!("{:?}", params); - // TODO: need to loop over diagnostics and distinguish them by URI + Notification::PublishDiagnostics(params) } - _ => println!("unhandled notification: {}", method), + _ => unimplemented!("unhandled notification: {}", method), } } } @@ -58,13 +59,13 @@ pub struct Client { stderr: BufReader, outgoing: Sender, - incoming: Receiver, + pub incoming: Receiver, pub request_counter: u64, capabilities: Option, // TODO: handle PublishDiagnostics Version - diagnostics: HashMap>, + // diagnostics: HashMap>, } impl Client { @@ -95,7 +96,7 @@ impl Client { request_counter: 0, capabilities: None, - diagnostics: HashMap::new(), + // diagnostics: HashMap::new(), } } @@ -226,10 +227,7 @@ impl Client { ) -> anyhow::Result<()> { self.notify::(lsp::DidOpenTextDocumentParams { text_document: lsp::TextDocumentItem { - uri: lsp::Url::from_file_path( - std::fs::canonicalize(state.path.as_ref().unwrap()).unwrap(), - ) - .unwrap(), + uri: lsp::Url::from_file_path(state.path().unwrap()).unwrap(), language_id: "rust".to_string(), // TODO: hardcoded for now version: 0, text: String::from(&state.doc), @@ -243,11 +241,12 @@ impl Client { &mut self, state: &helix_core::State, ) -> anyhow::Result<()> { - self.notify::(lsp::DidSaveTextDocumentParams { - text_document: lsp::TextDocumentIdentifier::new( - lsp::Url::from_file_path(state.path.as_ref().unwrap()).unwrap(), + self.notify::(lsp::DidChangeTextDocumentParams { + text_document: lsp::VersionedTextDocumentIdentifier::new( + lsp::Url::from_file_path(state.path().unwrap()).unwrap(), + 0, // TODO: version ), - text: None, // TODO? + content_changes: vec![], // TODO: }) .await } diff --git a/helix-lsp/src/transport.rs b/helix-lsp/src/transport.rs index c44ffa918..8915a9251 100644 --- a/helix-lsp/src/transport.rs +++ b/helix-lsp/src/transport.rs @@ -24,7 +24,7 @@ pub(crate) enum Payload { } pub(crate) struct Transport { - incoming: Sender, + incoming: Sender, // TODO Notification | Call outgoing: Receiver, pending_requests: HashMap>>, @@ -39,7 +39,7 @@ impl Transport { ex: &Executor, reader: BufReader, writer: BufWriter, - ) -> (Receiver, Sender) { + ) -> (Receiver, Sender) { let (incoming, rx) = smol::channel::unbounded(); let (tx, outgoing) = smol::channel::unbounded(); @@ -111,7 +111,7 @@ impl Transport { } pub async fn send(&mut self, request: String) -> anyhow::Result<()> { - println!("-> {}", request); + // println!("-> {}", request); // send the headers self.writer @@ -132,11 +132,11 @@ impl Transport { Message::Notification(jsonrpc::Notification { method, params, .. }) => { let notification = Notification::parse(&method, params); - println!("<- {} {:?}", method, notification); - // dispatch + // println!("<- {} {:?}", method, notification); + self.incoming.send(notification).await?; } Message::Call(call) => { - println!("<- {:?}", call); + // println!("<- {:?}", call); // dispatch } _ => unreachable!(), @@ -147,7 +147,7 @@ impl Transport { pub async fn recv_response(&mut self, output: jsonrpc::Output) -> anyhow::Result<()> { match output { jsonrpc::Output::Success(jsonrpc::Success { id, result, .. }) => { - println!("<- {}", result); + // println!("<- {}", result); let tx = self .pending_requests diff --git a/helix-term/Cargo.toml b/helix-term/Cargo.toml index aa91a095d..db1edee97 100644 --- a/helix-term/Cargo.toml +++ b/helix-term/Cargo.toml @@ -24,3 +24,5 @@ num_cpus = "1.13" tui = { git = "https://github.com/fdehau/tui-rs", default-features = false, features = ["crossterm"] } crossterm = { version = "0.18", features = ["event-stream"] } clap = { version = "3.0.0-beta.2 ", default-features = false, features = ["std", "cargo"] } + +futures-util = "0.3" diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs index d65e7e2e3..3d5b3459c 100644 --- a/helix-term/src/application.rs +++ b/helix-term/src/application.rs @@ -1,6 +1,11 @@ use clap::ArgMatches as Args; use helix_core::{indent::TAB_WIDTH, state::Mode, syntax::HighlightEvent, Position, Range, State}; -use helix_view::{commands, keymap, prompt::Prompt, Editor, Theme, View}; +use helix_view::{ + commands, + keymap::{self, Keymaps}, + prompt::Prompt, + Editor, Theme, View, +}; use std::{ borrow::Cow, @@ -31,14 +36,16 @@ const OFFSET: u16 = 6; // 5 linenr + 1 gutter type Terminal = tui::Terminal>; -static EX: smol::Executor = smol::Executor::new(); - const BASE_WIDTH: u16 = 30; -pub struct Application { +pub struct Application<'a> { editor: Editor, prompt: Option, terminal: Renderer, + + keymap: Keymaps, + executor: &'a smol::Executor<'a>, + lsp: helix_lsp::Client, } struct Renderer { @@ -235,7 +242,7 @@ impl Renderer { .set_string(1, self.size.1 - 2, mode, self.text_color); } - pub fn render_prompt(&mut self, view: &View, prompt: &Prompt) { + pub fn render_prompt(&mut self, view: &View, prompt: &Prompt, theme: &Theme) { // completion if !prompt.completion.is_empty() { // TODO: find out better way of clearing individual lines of the screen @@ -254,7 +261,7 @@ impl Renderer { } self.surface.set_style( Rect::new(0, self.size.1 - col_height - 2, self.size.0, col_height), - view.theme.get("ui.statusline"), + theme.get("ui.statusline"), ); for (i, command) in prompt.completion.iter().enumerate() { let color = if prompt.completion_selection_index.is_some() @@ -330,8 +337,8 @@ impl Renderer { } } -impl Application { - pub fn new(mut args: Args) -> Result { +impl<'a> Application<'a> { + pub fn new(mut args: Args, executor: &'a smol::Executor<'a>) -> Result { let terminal = Renderer::new()?; let mut editor = Editor::new(); @@ -339,11 +346,18 @@ impl Application { editor.open(file, terminal.size)?; } + let lsp = helix_lsp::Client::start(&executor, "rust-analyzer", &[]); + let mut app = Self { editor, terminal, // TODO; move to state prompt: None, + + // + keymap: keymap::default(), + executor, + lsp, }; Ok(app) @@ -361,7 +375,7 @@ impl Application { if prompt.should_close { self.prompt = None; } else { - self.terminal.render_prompt(view, prompt); + self.terminal.render_prompt(view, prompt, theme_ref); } } } @@ -375,7 +389,13 @@ impl Application { pub async fn event_loop(&mut self) { let mut reader = EventStream::new(); - let keymap = keymap::default(); + + // initialize lsp + let res = self.lsp.initialize().await; + let res = self + .lsp + .text_document_did_open(&self.editor.view().unwrap().state) + .await; self.render(); @@ -384,126 +404,149 @@ impl Application { break; } - // Handle key events - match reader.next().await { - Some(Ok(Event::Resize(width, height))) => { - self.terminal.resize(width, height); + use futures_util::{select, FutureExt}; + select! { + event = reader.next().fuse() => { + self.handle_terminal_events(event).await + } + notification = self.lsp.incoming.next().fuse() => { + self.handle_lsp_notification(notification).await + } + } + } + } - // TODO: simplistic ensure cursor in view for now - // TODO: loop over views - if let Some(view) = self.editor.view_mut() { - view.size = self.terminal.size; - view.ensure_cursor_in_view() - }; + pub async fn handle_terminal_events( + &mut self, + event: Option>, + ) { + // Handle key events + match event { + Some(Ok(Event::Resize(width, height))) => { + self.terminal.resize(width, height); + + // TODO: simplistic ensure cursor in view for now + // TODO: loop over views + if let Some(view) = self.editor.view_mut() { + view.size = self.terminal.size; + view.ensure_cursor_in_view() + }; + + self.render(); + } + Some(Ok(Event::Key(event))) => { + // if there's a prompt, it takes priority + if let Some(prompt) = &mut self.prompt { + self.prompt + .as_mut() + .unwrap() + .handle_input(event, &mut self.editor); self.render(); - } - Some(Ok(Event::Key(event))) => { - // if there's a prompt, it takes priority - if let Some(prompt) = &mut self.prompt { - self.prompt - .as_mut() - .unwrap() - .handle_input(event, &mut self.editor); - - self.render(); - } else if let Some(view) = self.editor.view_mut() { - let keys = vec![event]; - // TODO: sequences (`gg`) - // TODO: handle count other than 1 - match view.state.mode() { - Mode::Insert => { - if let Some(command) = keymap[&Mode::Insert].get(&keys) { - command(view, 1); - } else if let KeyEvent { - code: KeyCode::Char(c), - .. - } = event - { - commands::insert::insert_char(view, c); - } - view.ensure_cursor_in_view(); + } else if let Some(view) = self.editor.view_mut() { + let keys = vec![event]; + // TODO: sequences (`gg`) + // TODO: handle count other than 1 + match view.state.mode() { + Mode::Insert => { + if let Some(command) = self.keymap[&Mode::Insert].get(&keys) { + command(view, 1); + } else if let KeyEvent { + code: KeyCode::Char(c), + .. + } = event + { + commands::insert::insert_char(view, c); } - Mode::Normal => { - if let &[KeyEvent { - code: KeyCode::Char(':'), - .. - }] = keys.as_slice() - { - let prompt = Prompt::new( - ":".to_owned(), - |_input: &str| { - // TODO: i need this duplicate list right now to avoid borrow checker issues - let command_list = vec![ - String::from("q"), - String::from("aaa"), - String::from("bbb"), - String::from("ccc"), - String::from("ddd"), - String::from("eee"), - String::from("averylongcommandaverylongcommandaverylongcommandaverylongcommandaverylongcommand"), - String::from("q"), - String::from("aaa"), - String::from("bbb"), - String::from("ccc"), - String::from("ddd"), - String::from("eee"), - String::from("q"), - String::from("aaa"), - String::from("bbb"), - String::from("ccc"), - String::from("ddd"), - String::from("eee"), - String::from("q"), - String::from("aaa"), - String::from("bbb"), - String::from("ccc"), - String::from("ddd"), - String::from("eee"), - String::from("q"), - String::from("aaa"), - String::from("bbb"), - String::from("ccc"), - String::from("ddd"), - String::from("eee"), - ]; - command_list - .into_iter() - .filter(|command| command.contains(_input)) - .collect() - }, // completion - |editor: &mut Editor, input: &str| match input { - "q" => editor.should_close = true, - _ => (), - }, - ); - - self.prompt = Some(prompt); - - // HAXX: special casing for command mode - } else if let Some(command) = keymap[&Mode::Normal].get(&keys) { - command(view, 1); - - // TODO: simplistic ensure cursor in view for now - view.ensure_cursor_in_view(); - } + view.ensure_cursor_in_view(); + } + Mode::Normal => { + if let &[KeyEvent { + code: KeyCode::Char(':'), + .. + }] = keys.as_slice() + { + let prompt = Prompt::new( + ":".to_owned(), + |_input: &str| { + // TODO: i need this duplicate list right now to avoid borrow checker issues + let command_list = vec![ + String::from("q"), + String::from("aaa"), + String::from("bbb"), + String::from("ccc"), + String::from("ddd"), + String::from("eee"), + String::from("averylongcommandaverylongcommandaverylongcommandaverylongcommandaverylongcommand"), + String::from("q"), + String::from("aaa"), + String::from("bbb"), + String::from("ccc"), + String::from("ddd"), + String::from("eee"), + String::from("q"), + String::from("aaa"), + String::from("bbb"), + String::from("ccc"), + String::from("ddd"), + String::from("eee"), + String::from("q"), + String::from("aaa"), + String::from("bbb"), + String::from("ccc"), + String::from("ddd"), + String::from("eee"), + String::from("q"), + String::from("aaa"), + String::from("bbb"), + String::from("ccc"), + String::from("ddd"), + String::from("eee"), + ]; + command_list + .into_iter() + .filter(|command| command.contains(_input)) + .collect() + }, // completion + |editor: &mut Editor, input: &str| match input { + "q" => editor.should_close = true, + _ => (), + }, + ); + + self.prompt = Some(prompt); + + // HAXX: special casing for command mode + } else if let Some(command) = self.keymap[&Mode::Normal].get(&keys) { + command(view, 1); + + // TODO: simplistic ensure cursor in view for now + view.ensure_cursor_in_view(); } - mode => { - if let Some(command) = keymap[&mode].get(&keys) { - command(view, 1); + } + mode => { + if let Some(command) = self.keymap[&mode].get(&keys) { + command(view, 1); - // TODO: simplistic ensure cursor in view for now - view.ensure_cursor_in_view(); - } + // TODO: simplistic ensure cursor in view for now + view.ensure_cursor_in_view(); } } - self.render(); } + self.render(); } - Some(Ok(Event::Mouse(_))) => (), // unhandled - Some(Err(x)) => panic!(x), - None => break, } + Some(Ok(Event::Mouse(_))) => (), // unhandled + Some(Err(x)) => panic!(x), + None => panic!(), + }; + } + + pub async fn handle_lsp_notification(&mut self, notification: Option) { + use helix_lsp::Notification; + match notification { + Some(Notification::PublishDiagnostics(params)) => unimplemented!("{:?}", params), + _ => unreachable!(), } } diff --git a/helix-term/src/main.rs b/helix-term/src/main.rs index 07f1ffffa..de3a01755 100644 --- a/helix-term/src/main.rs +++ b/helix-term/src/main.rs @@ -26,15 +26,15 @@ fn main() -> Result<(), Error> { std::thread::spawn(move || smol::block_on(EX.run(smol::future::pending::<()>()))); } - let mut lsp = helix_lsp::Client::start(&EX, "rust-analyzer", &[]); + // let mut lsp = helix_lsp::Client::start(&EX, "rust-analyzer", &[]); smol::block_on(async { - let res = lsp.initialize().await; - let state = helix_core::State::load("test.rs".into(), &[]).unwrap(); - let res = lsp.text_document_did_open(&state).await; - loop {} + // let res = lsp.initialize().await; + // let state = helix_core::State::load("test.rs".into(), &[]).unwrap(); + // let res = lsp.text_document_did_open(&state).await; + // loop {} - // Application::new(args).unwrap().run().await; + Application::new(args, &EX).unwrap().run().await; }); Ok(()) diff --git a/helix-view/src/keymap.rs b/helix-view/src/keymap.rs index 69e6cabbf..82bdbe21f 100644 --- a/helix-view/src/keymap.rs +++ b/helix-view/src/keymap.rs @@ -87,8 +87,8 @@ use std::collections::HashMap; pub use crossterm::event::{KeyCode, KeyEvent as Key, KeyModifiers as Modifiers}; // TODO: could be trie based -type Keymap = HashMap, Command>; -type Keymaps = HashMap; +pub type Keymap = HashMap, Command>; +pub type Keymaps = HashMap; macro_rules! key { ($ch:expr) => { diff --git a/helix-view/src/view.rs b/helix-view/src/view.rs index d2a7d5562..817714c8e 100644 --- a/helix-view/src/view.rs +++ b/helix-view/src/view.rs @@ -18,7 +18,7 @@ pub struct View { pub first_line: usize, pub size: (u16, u16), - // TODO: Doc<> fields + // TODO: Doc fields pub history: History, } From 49254d7180c8b92be5426cab20914b0343c9282c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Hrastnik?= Date: Tue, 20 Oct 2020 15:42:53 +0900 Subject: [PATCH 07/23] Total mess but it works: diagnostic marking. --- helix-core/src/diagnostic.rs | 8 +++- helix-lsp/src/lib.rs | 3 ++ helix-term/src/application.rs | 84 ++++++++++++++++++++++++++++++++--- helix-view/src/theme.rs | 2 + 4 files changed, 91 insertions(+), 6 deletions(-) diff --git a/helix-core/src/diagnostic.rs b/helix-core/src/diagnostic.rs index aee648aa4..96ed67462 100644 --- a/helix-core/src/diagnostic.rs +++ b/helix-core/src/diagnostic.rs @@ -1 +1,7 @@ -pub struct Diagnostic {} +use crate::Range; + +pub struct Diagnostic { + pub range: (usize, usize), + pub line: usize, + pub message: String, +} diff --git a/helix-lsp/src/lib.rs b/helix-lsp/src/lib.rs index 3598a5943..939f99271 100644 --- a/helix-lsp/src/lib.rs +++ b/helix-lsp/src/lib.rs @@ -10,6 +10,9 @@ use serde_json::Value; use serde::{Deserialize, Serialize}; +pub use lsp::Position; +pub use lsp::Url; + use smol::prelude::*; use smol::{ channel::{Receiver, Sender}, diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs index 3d5b3459c..5551e26f4 100644 --- a/helix-term/src/application.rs +++ b/helix-term/src/application.rs @@ -29,10 +29,10 @@ use tui::{ backend::CrosstermBackend, buffer::Buffer as Surface, layout::Rect, - style::{Color, Style}, + style::{Color, Modifier, Style}, }; -const OFFSET: u16 = 6; // 5 linenr + 1 gutter +const OFFSET: u16 = 7; // 1 diagnostic + 5 linenr + 1 gutter type Terminal = tui::Terminal>; @@ -205,6 +205,16 @@ impl Renderer { style }; + // ugh, improve with a traverse method + // or interleave highlight spans with selection and diagnostic spans + let style = if view.state.diagnostics.iter().any(|diagnostic| { + diagnostic.range.0 <= char_index && diagnostic.range.1 > char_index + }) { + style.clone().add_modifier(Modifier::UNDERLINED) + } else { + style + }; + // TODO: paint cursor heads except primary self.surface @@ -212,18 +222,23 @@ impl Renderer { visual_x += width; } - // if grapheme == "\t" char_index += 1; } } } } + let style: Style = theme.get("ui.linenr"); + let warning: Style = theme.get("warning"); let last_line = view.last_line(); for (i, line) in (view.first_line..last_line).enumerate() { + if view.state.diagnostics.iter().any(|d| d.line == line) { + self.surface.set_stringn(0, i as u16, "●", 1, warning); + } + self.surface - .set_stringn(0, i as u16, format!("{:>5}", line + 1), 5, style); + .set_stringn(1, i as u16, format!("{:>5}", line + 1), 5, style); } } @@ -240,6 +255,13 @@ impl Renderer { ); self.surface .set_string(1, self.size.1 - 2, mode, self.text_color); + + self.surface.set_string( + self.size.0 - 10, + self.size.1 - 2, + format!("{}", view.state.diagnostics.len()), + self.text_color, + ); } pub fn render_prompt(&mut self, view: &View, prompt: &Prompt, theme: &Theme) { @@ -545,7 +567,59 @@ impl<'a> Application<'a> { pub async fn handle_lsp_notification(&mut self, notification: Option) { use helix_lsp::Notification; match notification { - Some(Notification::PublishDiagnostics(params)) => unimplemented!("{:?}", params), + Some(Notification::PublishDiagnostics(params)) => { + let view = self.editor.views.iter_mut().find(|view| { + let path = view + .state + .path + .as_ref() + .map(|path| helix_lsp::Url::from_file_path(path).unwrap()); + + eprintln!("{:?} {} {}", path, params.uri, params.diagnostics.len()); + // HAXX + path == Some(params.uri.clone()) + }); + + fn lsp_pos_to_pos(doc: &helix_core::RopeSlice, pos: helix_lsp::Position) -> usize { + let line = doc.line_to_char(pos.line as usize); + let line_start = doc.char_to_utf16_cu(line); + doc.utf16_cu_to_char(pos.character as usize + line_start) + } + + if let Some(view) = view { + let doc = view.state.doc().slice(..); + let diagnostics = params + .diagnostics + .into_iter() + .map(|diagnostic| { + let start = lsp_pos_to_pos(&doc, diagnostic.range.start); + let end = lsp_pos_to_pos(&doc, diagnostic.range.end); + + // eprintln!( + // "{:?}-{:?} {}-{} {}", + // diagnostic.range.start, + // diagnostic.range.end, + // start, + // end, + // diagnostic.message + // ); + + helix_core::Diagnostic { + range: (start, end), + line: diagnostic.range.start.line as usize, + message: diagnostic.message, + // severity + // code + // source + } + }) + .collect(); + + view.state.diagnostics = diagnostics; + + self.render(); + } + } _ => unreachable!(), } } diff --git a/helix-view/src/theme.rs b/helix-view/src/theme.rs index 4cc399ed4..809ec05d4 100644 --- a/helix-view/src/theme.rs +++ b/helix-view/src/theme.rs @@ -157,6 +157,8 @@ impl Default for Theme { "ui.background" => Style::default().bg(Color::Rgb(59, 34, 76)), // midnight "ui.linenr" => Style::default().fg(Color::Rgb(90, 89, 119)), // comet "ui.statusline" => Style::default().bg(Color::Rgb(40, 23, 51)), // revolver + + "warning" => Style::default().fg(Color::Rgb(255, 205, 28)), }; let scopes = mapping.keys().map(ToString::to_string).collect(); From ef5e5f9296d27d11ddfddf6d1c7daf93f9464ddb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Hrastnik?= Date: Wed, 21 Oct 2020 13:47:20 +0900 Subject: [PATCH 08/23] state.version tracking --- helix-core/src/state.rs | 2 ++ helix-lsp/src/lib.rs | 32 +++++++++++++++++++++----------- helix-term/src/application.rs | 33 +++++++-------------------------- helix-view/src/commands.rs | 7 ++++++- 4 files changed, 36 insertions(+), 38 deletions(-) diff --git a/helix-core/src/state.rs b/helix-core/src/state.rs index 0f94f696f..75e5cd40e 100644 --- a/helix-core/src/state.rs +++ b/helix-core/src/state.rs @@ -29,6 +29,7 @@ pub struct State { pub changes: ChangeSet, pub old_state: Option<(Rope, Selection)>, + pub version: i64, pub diagnostics: Vec, } @@ -61,6 +62,7 @@ impl State { changes, old_state, diagnostics: Vec::new(), + version: 0, } } diff --git a/helix-lsp/src/lib.rs b/helix-lsp/src/lib.rs index 939f99271..f8c73902b 100644 --- a/helix-lsp/src/lib.rs +++ b/helix-lsp/src/lib.rs @@ -2,6 +2,8 @@ mod transport; use transport::{Payload, Transport}; +use helix_core::{State, Transaction}; + // use std::collections::HashMap; use jsonrpc_core as jsonrpc; @@ -13,14 +15,24 @@ use serde::{Deserialize, Serialize}; pub use lsp::Position; pub use lsp::Url; -use smol::prelude::*; use smol::{ channel::{Receiver, Sender}, io::{BufReader, BufWriter}, + // prelude::*, process::{Child, ChildStderr, Command, Stdio}, Executor, }; +pub mod util { + use super::*; + + pub fn lsp_pos_to_pos(doc: &helix_core::RopeSlice, pos: lsp::Position) -> usize { + let line = doc.line_to_char(pos.line as usize); + let line_start = doc.char_to_utf16_cu(line); + doc.utf16_cu_to_char(pos.character as usize + line_start) + } +} + /// A type representing all possible values sent from the server to the client. #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(deny_unknown_fields)] @@ -58,7 +70,7 @@ impl Notification { } pub struct Client { - process: Child, + _process: Child, stderr: BufReader, outgoing: Sender, @@ -90,7 +102,7 @@ impl Client { let (incoming, outgoing) = Transport::start(ex, reader, writer); Client { - process, + _process: process, stderr, outgoing, @@ -224,15 +236,12 @@ impl Client { // Text document // ------------------------------------------------------------------------------------------- - pub async fn text_document_did_open( - &mut self, - state: &helix_core::State, - ) -> anyhow::Result<()> { + pub async fn text_document_did_open(&mut self, state: &State) -> anyhow::Result<()> { self.notify::(lsp::DidOpenTextDocumentParams { text_document: lsp::TextDocumentItem { uri: lsp::Url::from_file_path(state.path().unwrap()).unwrap(), language_id: "rust".to_string(), // TODO: hardcoded for now - version: 0, + version: state.version, text: String::from(&state.doc), }, }) @@ -242,14 +251,15 @@ impl Client { // TODO: trigger any time history.commit_revision happens pub async fn text_document_did_change( &mut self, - state: &helix_core::State, + state: &State, + transaction: &Transaction, ) -> anyhow::Result<()> { self.notify::(lsp::DidChangeTextDocumentParams { text_document: lsp::VersionedTextDocumentIdentifier::new( lsp::Url::from_file_path(state.path().unwrap()).unwrap(), - 0, // TODO: version + state.version, ), - content_changes: vec![], // TODO: + content_changes: vec![], // TODO: probably need old_state here too? }) .await } diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs index 5551e26f4..a1a6b9ea7 100644 --- a/helix-term/src/application.rs +++ b/helix-term/src/application.rs @@ -568,23 +568,12 @@ impl<'a> Application<'a> { use helix_lsp::Notification; match notification { Some(Notification::PublishDiagnostics(params)) => { - let view = self.editor.views.iter_mut().find(|view| { - let path = view - .state - .path - .as_ref() - .map(|path| helix_lsp::Url::from_file_path(path).unwrap()); - - eprintln!("{:?} {} {}", path, params.uri, params.diagnostics.len()); - // HAXX - path == Some(params.uri.clone()) - }); - - fn lsp_pos_to_pos(doc: &helix_core::RopeSlice, pos: helix_lsp::Position) -> usize { - let line = doc.line_to_char(pos.line as usize); - let line_start = doc.char_to_utf16_cu(line); - doc.utf16_cu_to_char(pos.character as usize + line_start) - } + let path = Some(params.uri.to_file_path().unwrap()); + let view = self + .editor + .views + .iter_mut() + .find(|view| view.state.path == path); if let Some(view) = view { let doc = view.state.doc().slice(..); @@ -592,18 +581,10 @@ impl<'a> Application<'a> { .diagnostics .into_iter() .map(|diagnostic| { + use helix_lsp::util::lsp_pos_to_pos; let start = lsp_pos_to_pos(&doc, diagnostic.range.start); let end = lsp_pos_to_pos(&doc, diagnostic.range.end); - // eprintln!( - // "{:?}-{:?} {}-{} {}", - // diagnostic.range.start, - // diagnostic.range.end, - // start, - // end, - // diagnostic.message - // ); - helix_core::Diagnostic { range: (start, end), line: diagnostic.range.start.line as usize, diff --git a/helix-view/src/commands.rs b/helix-view/src/commands.rs index 1d7737f00..e29d070ec 100644 --- a/helix-view/src/commands.rs +++ b/helix-view/src/commands.rs @@ -391,6 +391,12 @@ fn append_changes_to_history(view: &mut View) { // annotations either add a new layer or compose into the previous one. let transaction = Transaction::from(changes).with_selection(view.state.selection().clone()); + // increment document version + // TODO: needs to happen on undo/redo too + view.state.version += 1; + + // TODO: trigger lsp/documentDidChange with changes + // HAXX: we need to reconstruct the state as it was before the changes.. let (doc, selection) = view.state.old_state.take().unwrap(); let mut old_state = State::new(doc); @@ -399,7 +405,6 @@ fn append_changes_to_history(view: &mut View) { // TODO: take transaction by value? view.history.commit_revision(&transaction, &old_state); - // TODO: need to start the state with these vals // HAXX view.state.old_state = Some((view.state.doc().clone(), view.state.selection.clone())); } From 81ccca0c6a18de86223b8142b5742e0603b9b230 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Hrastnik?= Date: Wed, 21 Oct 2020 16:42:45 +0900 Subject: [PATCH 09/23] Improve error typing. --- Cargo.lock | 41 +++++-- helix-lsp/Cargo.toml | 1 + helix-lsp/src/client.rs | 242 +++++++++++++++++++++++++++++++++++++ helix-lsp/src/lib.rs | 241 +++--------------------------------- helix-lsp/src/transport.rs | 25 ++-- 5 files changed, 308 insertions(+), 242 deletions(-) create mode 100644 helix-lsp/src/client.rs diff --git a/Cargo.lock b/Cargo.lock index 2e329fd1c..1d7857d58 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -100,9 +100,9 @@ dependencies = [ [[package]] name = "async-net" -version = "1.4.7" +version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ee4c3668eb091d781e97f0026b5289b457c77d407a85749a9bb4c057456c428f" +checksum = "06de475c85affe184648202401d7622afb32f0f74e02192857d0201a16defbe5" dependencies = [ "async-io", "blocking", @@ -350,9 +350,9 @@ checksum = "5fc94b64bb39543b4e432f1790b6bf18e3ee3b74653c5449f63310e9a74b123c" [[package]] name = "futures-lite" -version = "1.11.1" +version = "1.11.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "381a7ad57b1bad34693f63f6f377e1abded7a9c85c9d3eb6771e11c60aaadab9" +checksum = "5e6c079abfac3ab269e2927ec048dabc89d009ebfdda6b8ee86624f30c689658" dependencies = [ "fastrand", "futures-core", @@ -454,6 +454,7 @@ dependencies = [ "serde_json", "shellexpand", "smol", + "thiserror", "url", ] @@ -623,9 +624,9 @@ checksum = "3728d817d99e5ac407411fa471ff9800a778d88a24685968b36824eaf4bee400" [[package]] name = "mio" -version = "0.7.3" +version = "0.7.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e53a6ea5f38c0a48ca42159868c6d8e1bd56c0451238856cc08d58563643bdc3" +checksum = "f8f1c83949125de4a582aa2da15ae6324d91cf6a58a70ea407643941ff98f558" dependencies = [ "libc", "log", @@ -757,9 +758,9 @@ dependencies = [ [[package]] name = "pin-project-lite" -version = "0.1.10" +version = "0.1.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e555d9e657502182ac97b539fb3dae8b79cda19e3e4f8ffb5e8de4f18df93c95" +checksum = "c917123afa01924fc84bb20c4c03f004d9c38e5127e3c039bbf7f4b9c76a2f6b" [[package]] name = "pin-utils" @@ -1022,6 +1023,26 @@ dependencies = [ "unicode-width", ] +[[package]] +name = "thiserror" +version = "1.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "318234ffa22e0920fe9a40d7b8369b5f649d490980cf7aadcf1eb91594869b42" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cae2447b6282786c3493999f40a9be2a6ad20cb8bd268b0a0dbf5a065535c0ab" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "thread_local" version = "1.0.1" @@ -1139,9 +1160,9 @@ checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519" [[package]] name = "wepoll-sys" -version = "3.0.0" +version = "3.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "142bc2cba3fe88be1a8fcb55c727fa4cd5b0cf2d7438722792e22f26f04bc1e0" +checksum = "0fcb14dea929042224824779fbc82d9fab8d2e6d3cbc0ac404de8edf489e77ff" dependencies = [ "cc", ] diff --git a/helix-lsp/Cargo.toml b/helix-lsp/Cargo.toml index b34c139f0..e4956f0b6 100644 --- a/helix-lsp/Cargo.toml +++ b/helix-lsp/Cargo.toml @@ -20,3 +20,4 @@ serde_json = "1.0" serde = { version = "1.0", features = ["derive"] } jsonrpc-core = "15.1" futures-util = "0.3" +thiserror = "1.0.21" diff --git a/helix-lsp/src/client.rs b/helix-lsp/src/client.rs new file mode 100644 index 000000000..93e137cb9 --- /dev/null +++ b/helix-lsp/src/client.rs @@ -0,0 +1,242 @@ +use crate::{ + transport::{Payload, Transport}, + Error, Notification, +}; + +type Result = core::result::Result; + +use helix_core::{State, Transaction}; + +// use std::collections::HashMap; + +use jsonrpc_core as jsonrpc; +use lsp_types as lsp; +use serde_json::Value; + +use smol::{ + channel::{Receiver, Sender}, + io::{BufReader, BufWriter}, + // prelude::*, + process::{Child, ChildStderr, Command, Stdio}, + Executor, +}; + +pub struct Client { + _process: Child, + stderr: BufReader, + + outgoing: Sender, + pub incoming: Receiver, + + pub request_counter: u64, + + capabilities: Option, + // TODO: handle PublishDiagnostics Version + // diagnostics: HashMap>, +} + +impl Client { + pub fn start(ex: &Executor, cmd: &str, args: &[String]) -> Self { + let mut process = Command::new(cmd) + .args(args) + .stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .spawn() + .expect("Failed to start language server"); + // smol makes sure the process is reaped on drop, but using kill_on_drop(true) maybe? + + // TODO: do we need bufreader/writer here? or do we use async wrappers on unblock? + let writer = BufWriter::new(process.stdin.take().expect("Failed to open stdin")); + let reader = BufReader::new(process.stdout.take().expect("Failed to open stdout")); + let stderr = BufReader::new(process.stderr.take().expect("Failed to open stderr")); + + let (incoming, outgoing) = Transport::start(ex, reader, writer); + + Client { + _process: process, + stderr, + + outgoing, + incoming, + + request_counter: 0, + + capabilities: None, + // diagnostics: HashMap::new(), + } + } + + fn next_request_id(&mut self) -> jsonrpc::Id { + let id = jsonrpc::Id::Num(self.request_counter); + self.request_counter += 1; + id + } + + fn to_params(value: Value) -> Result { + use jsonrpc::Params; + + let params = match value { + Value::Null => Params::None, + Value::Bool(_) | Value::Number(_) | Value::String(_) => Params::Array(vec![value]), + Value::Array(vec) => Params::Array(vec), + Value::Object(map) => Params::Map(map), + }; + + Ok(params) + } + + pub async fn request( + &mut self, + params: R::Params, + ) -> Result + where + R::Params: serde::Serialize, + R::Result: core::fmt::Debug, // TODO: temporary + { + let params = serde_json::to_value(params)?; + + let request = jsonrpc::MethodCall { + jsonrpc: Some(jsonrpc::Version::V2), + id: self.next_request_id(), + method: R::METHOD.to_string(), + params: Self::to_params(params)?, + }; + + let (tx, rx) = smol::channel::bounded::>(1); + + self.outgoing + .send(Payload::Request { + chan: tx, + value: request, + }) + .await + .map_err(|e| Error::Other(e.into()))?; + + let response = rx.recv().await.map_err(|e| Error::Other(e.into()))??; + + let response = serde_json::from_value(response)?; + + // TODO: we should pass request to a sender thread via a channel + // so it can't be interleaved + + // TODO: responses can be out of order, we need to register a single shot response channel + + Ok(response) + } + + pub async fn notify( + &mut self, + params: R::Params, + ) -> Result<()> + where + R::Params: serde::Serialize, + { + let params = serde_json::to_value(params)?; + + let notification = jsonrpc::Notification { + jsonrpc: Some(jsonrpc::Version::V2), + method: R::METHOD.to_string(), + params: Self::to_params(params)?, + }; + + self.outgoing + .send(Payload::Notification(notification)) + .await + .map_err(|e| Error::Other(e.into()))?; + + Ok(()) + } + + // ------------------------------------------------------------------------------------------- + // General messages + // ------------------------------------------------------------------------------------------- + + pub async fn initialize(&mut self) -> Result<()> { + // TODO: delay any requests that are triggered prior to initialize + + #[allow(deprecated)] + let params = lsp::InitializeParams { + process_id: Some(u64::from(std::process::id())), + root_path: None, + // root_uri: Some(lsp_types::Url::parse("file://localhost/")?), + root_uri: None, // set to project root in the future + initialization_options: None, + capabilities: lsp::ClientCapabilities::default(), + trace: None, + workspace_folders: None, + client_info: None, + }; + + let response = self.request::(params).await?; + self.capabilities = Some(response.capabilities); + + // next up, notify + self.notify::(lsp::InitializedParams {}) + .await?; + + Ok(()) + } + + pub async fn shutdown(&mut self) -> Result<()> { + self.request::(()).await + } + + pub async fn exit(&mut self) -> Result<()> { + self.notify::(()).await + } + + // ------------------------------------------------------------------------------------------- + // Text document + // ------------------------------------------------------------------------------------------- + + pub async fn text_document_did_open(&mut self, state: &State) -> Result<()> { + self.notify::(lsp::DidOpenTextDocumentParams { + text_document: lsp::TextDocumentItem { + uri: lsp::Url::from_file_path(state.path().unwrap()).unwrap(), + language_id: "rust".to_string(), // TODO: hardcoded for now + version: state.version, + text: String::from(&state.doc), + }, + }) + .await + } + + // TODO: trigger any time history.commit_revision happens + pub async fn text_document_did_change( + &mut self, + state: &State, + transaction: &Transaction, + ) -> Result<()> { + self.notify::(lsp::DidChangeTextDocumentParams { + text_document: lsp::VersionedTextDocumentIdentifier::new( + lsp::Url::from_file_path(state.path().unwrap()).unwrap(), + state.version, + ), + content_changes: vec![lsp::TextDocumentContentChangeEvent { + // range = None -> whole document + range: None, //Some(Range) + range_length: None, // u64 apparently deprecated + text: "".to_string(), + }], // TODO: probably need old_state here too? + }) + .await + } + + // TODO: impl into() TextDocumentIdentifier / VersionedTextDocumentIdentifier for State. + + pub async fn text_document_did_close(&mut self, state: &State) -> Result<()> { + self.notify::(lsp::DidCloseTextDocumentParams { + text_document: lsp::TextDocumentIdentifier::new( + lsp::Url::from_file_path(state.path().unwrap()).unwrap(), + ), + }) + .await + } + + // will_save / will_save_wait_until + + pub async fn text_document_did_save(&mut self) -> anyhow::Result<()> { + unimplemented!() + } +} diff --git a/helix-lsp/src/lib.rs b/helix-lsp/src/lib.rs index f8c73902b..c37222f14 100644 --- a/helix-lsp/src/lib.rs +++ b/helix-lsp/src/lib.rs @@ -1,27 +1,26 @@ +mod client; mod transport; -use transport::{Payload, Transport}; - -use helix_core::{State, Transaction}; - -// use std::collections::HashMap; - use jsonrpc_core as jsonrpc; use lsp_types as lsp; -use serde_json::Value; - -use serde::{Deserialize, Serialize}; -pub use lsp::Position; -pub use lsp::Url; +pub use client::Client; +pub use lsp::{Position, Url}; -use smol::{ - channel::{Receiver, Sender}, - io::{BufReader, BufWriter}, - // prelude::*, - process::{Child, ChildStderr, Command, Stdio}, - Executor, -}; +use serde::{Deserialize, Serialize}; +use thiserror::Error; + +#[derive(Error, Debug)] +pub enum Error { + #[error("protocol error: {0}")] + Rpc(#[from] jsonrpc::Error), + #[error("failed to parse: {0}")] + Parse(#[from] serde_json::Error), + #[error("request timed out")] + Timeout, + #[error(transparent)] + Other(#[from] anyhow::Error), +} pub mod util { use super::*; @@ -68,209 +67,3 @@ impl Notification { } } } - -pub struct Client { - _process: Child, - stderr: BufReader, - - outgoing: Sender, - pub incoming: Receiver, - - pub request_counter: u64, - - capabilities: Option, - // TODO: handle PublishDiagnostics Version - // diagnostics: HashMap>, -} - -impl Client { - pub fn start(ex: &Executor, cmd: &str, args: &[String]) -> Self { - let mut process = Command::new(cmd) - .args(args) - .stdin(Stdio::piped()) - .stdout(Stdio::piped()) - .stderr(Stdio::piped()) - .spawn() - .expect("Failed to start language server"); - // smol makes sure the process is reaped on drop, but using kill_on_drop(true) maybe? - - // TODO: do we need bufreader/writer here? or do we use async wrappers on unblock? - let writer = BufWriter::new(process.stdin.take().expect("Failed to open stdin")); - let reader = BufReader::new(process.stdout.take().expect("Failed to open stdout")); - let stderr = BufReader::new(process.stderr.take().expect("Failed to open stderr")); - - let (incoming, outgoing) = Transport::start(ex, reader, writer); - - Client { - _process: process, - stderr, - - outgoing, - incoming, - - request_counter: 0, - - capabilities: None, - // diagnostics: HashMap::new(), - } - } - - fn next_request_id(&mut self) -> jsonrpc::Id { - let id = jsonrpc::Id::Num(self.request_counter); - self.request_counter += 1; - id - } - - fn to_params(value: Value) -> anyhow::Result { - use jsonrpc::Params; - - let params = match value { - Value::Null => Params::None, - Value::Bool(_) | Value::Number(_) | Value::String(_) => Params::Array(vec![value]), - Value::Array(vec) => Params::Array(vec), - Value::Object(map) => Params::Map(map), - }; - - Ok(params) - } - - pub async fn request( - &mut self, - params: R::Params, - ) -> anyhow::Result - where - R::Params: serde::Serialize, - R::Result: core::fmt::Debug, // TODO: temporary - { - let params = serde_json::to_value(params)?; - - let request = jsonrpc::MethodCall { - jsonrpc: Some(jsonrpc::Version::V2), - id: self.next_request_id(), - method: R::METHOD.to_string(), - params: Self::to_params(params)?, - }; - - let (tx, rx) = smol::channel::bounded::>(1); - - self.outgoing - .send(Payload::Request { - chan: tx, - value: request, - }) - .await?; - - let response = rx.recv().await??; - - let response = serde_json::from_value(response)?; - - // TODO: we should pass request to a sender thread via a channel - // so it can't be interleaved - - // TODO: responses can be out of order, we need to register a single shot response channel - - Ok(response) - } - - pub async fn notify( - &mut self, - params: R::Params, - ) -> anyhow::Result<()> - where - R::Params: serde::Serialize, - { - let params = serde_json::to_value(params)?; - - let notification = jsonrpc::Notification { - jsonrpc: Some(jsonrpc::Version::V2), - method: R::METHOD.to_string(), - params: Self::to_params(params)?, - }; - - self.outgoing - .send(Payload::Notification(notification)) - .await?; - - Ok(()) - } - - // ------------------------------------------------------------------------------------------- - // General messages - // ------------------------------------------------------------------------------------------- - - pub async fn initialize(&mut self) -> anyhow::Result<()> { - // TODO: delay any requests that are triggered prior to initialize - - #[allow(deprecated)] - let params = lsp::InitializeParams { - process_id: Some(u64::from(std::process::id())), - root_path: None, - // root_uri: Some(lsp_types::Url::parse("file://localhost/")?), - root_uri: None, // set to project root in the future - initialization_options: None, - capabilities: lsp::ClientCapabilities::default(), - trace: None, - workspace_folders: None, - client_info: None, - }; - - let response = self.request::(params).await?; - self.capabilities = Some(response.capabilities); - - // next up, notify - self.notify::(lsp::InitializedParams {}) - .await?; - - Ok(()) - } - - pub async fn shutdown(&mut self) -> anyhow::Result<()> { - self.request::(()).await - } - - pub async fn exit(&mut self) -> anyhow::Result<()> { - self.notify::(()).await - } - - // ------------------------------------------------------------------------------------------- - // Text document - // ------------------------------------------------------------------------------------------- - - pub async fn text_document_did_open(&mut self, state: &State) -> anyhow::Result<()> { - self.notify::(lsp::DidOpenTextDocumentParams { - text_document: lsp::TextDocumentItem { - uri: lsp::Url::from_file_path(state.path().unwrap()).unwrap(), - language_id: "rust".to_string(), // TODO: hardcoded for now - version: state.version, - text: String::from(&state.doc), - }, - }) - .await - } - - // TODO: trigger any time history.commit_revision happens - pub async fn text_document_did_change( - &mut self, - state: &State, - transaction: &Transaction, - ) -> anyhow::Result<()> { - self.notify::(lsp::DidChangeTextDocumentParams { - text_document: lsp::VersionedTextDocumentIdentifier::new( - lsp::Url::from_file_path(state.path().unwrap()).unwrap(), - state.version, - ), - content_changes: vec![], // TODO: probably need old_state here too? - }) - .await - } - - pub async fn text_document_did_close(&mut self) -> anyhow::Result<()> { - unimplemented!() - } - - // will_save / will_save_wait_until - - pub async fn text_document_did_save(&mut self) -> anyhow::Result<()> { - unimplemented!() - } -} diff --git a/helix-lsp/src/transport.rs b/helix-lsp/src/transport.rs index 8915a9251..38c3bb578 100644 --- a/helix-lsp/src/transport.rs +++ b/helix-lsp/src/transport.rs @@ -1,9 +1,10 @@ use std::collections::HashMap; -use crate::{Message, Notification}; +use crate::{Error, Message, Notification}; + +type Result = core::result::Result; use jsonrpc_core as jsonrpc; -use lsp_types as lsp; use serde_json::Value; use smol::prelude::*; @@ -17,7 +18,7 @@ use smol::{ pub(crate) enum Payload { Request { - chan: Sender>, + chan: Sender>, value: jsonrpc::MethodCall, }, Notification(jsonrpc::Notification), @@ -27,7 +28,7 @@ pub(crate) struct Transport { incoming: Sender, // TODO Notification | Call outgoing: Receiver, - pending_requests: HashMap>>, + pending_requests: HashMap>>, headers: HashMap, writer: BufWriter, @@ -60,7 +61,7 @@ impl Transport { async fn recv( reader: &mut (impl AsyncBufRead + Unpin), headers: &mut HashMap, - ) -> Result { + ) -> core::result::Result { // read headers loop { let mut header = String::new(); @@ -74,8 +75,10 @@ impl Transport { let parts: Vec<&str> = header.split(": ").collect(); if parts.len() != 2 { - // return Err(Error::new(ErrorKind::Other, "Failed to parse header")); - panic!() + return Err(std::io::Error::new( + std::io::ErrorKind::Other, + "Failed to parse header", + )); } headers.insert(parts[0].to_string(), parts[1].to_string()); } @@ -155,7 +158,13 @@ impl Transport { .expect("pending_request with id not found!"); tx.send(Ok(result)).await?; } - jsonrpc::Output::Failure(_) => panic!("recv fail"), + jsonrpc::Output::Failure(jsonrpc::Failure { id, error, .. }) => { + let tx = self + .pending_requests + .remove(&id) + .expect("pending_request with id not found!"); + tx.send(Err(error.into())).await?; + } msg => unimplemented!("{:?}", msg), } Ok(()) From b39849dde1b1277d14dbc4e2e1604e5d020db43d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Hrastnik?= Date: Thu, 22 Oct 2020 14:35:07 +0900 Subject: [PATCH 10/23] Refactor: Document type as a wrapper around barebones State. --- Cargo.lock | 2 + helix-core/src/indent.rs | 29 ++-- helix-core/src/state.rs | 81 ----------- helix-core/src/syntax.rs | 2 +- helix-core/src/transaction.rs | 36 +---- helix-lsp/Cargo.toml | 1 + helix-lsp/src/client.rs | 21 +-- helix-term/src/application.rs | 48 ++++--- helix-view/Cargo.toml | 1 + helix-view/src/commands.rs | 255 ++++++++++++++++++---------------- helix-view/src/document.rs | 157 +++++++++++++++++++++ helix-view/src/editor.rs | 7 +- helix-view/src/keymap.rs | 9 +- helix-view/src/lib.rs | 2 + helix-view/src/view.rs | 40 ++++-- 15 files changed, 396 insertions(+), 295 deletions(-) create mode 100644 helix-view/src/document.rs diff --git a/Cargo.lock b/Cargo.lock index 1d7857d58..29a86a36c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -447,6 +447,7 @@ dependencies = [ "futures-util", "glob", "helix-core", + "helix-view", "jsonrpc-core", "lsp-types", "pathdiff", @@ -491,6 +492,7 @@ dependencies = [ "helix-core", "once_cell", "tui", + "url", ] [[package]] diff --git a/helix-core/src/indent.rs b/helix-core/src/indent.rs index 2e1a095ef..6b9a1ab17 100644 --- a/helix-core/src/indent.rs +++ b/helix-core/src/indent.rs @@ -111,17 +111,17 @@ fn find_first_non_whitespace_char(state: &State, line_num: usize) -> usize { start } -fn suggested_indent_for_line(state: &State, line_num: usize) -> usize { +fn suggested_indent_for_line(syntax: Option<&Syntax>, state: &State, line_num: usize) -> usize { let line = state.doc.line(line_num); let current = indent_level_for_line(line); let start = find_first_non_whitespace_char(state, line_num); - suggested_indent_for_pos(state, start) + suggested_indent_for_pos(syntax, state, start) } -pub fn suggested_indent_for_pos(state: &State, pos: usize) -> usize { - if let Some(syntax) = &state.syntax { +pub fn suggested_indent_for_pos(syntax: Option<&Syntax>, state: &State, pos: usize) -> usize { + if let Some(syntax) = syntax { let byte_start = state.doc.char_to_byte(pos); let node = get_highest_syntax_node_at_bytepos(syntax, byte_start); @@ -163,13 +163,18 @@ mod test { ", ); - let mut state = State::new(doc); - state.set_language("source.rust", &[]); - - assert_eq!(suggested_indent_for_line(&state, 0), 0); // mod - assert_eq!(suggested_indent_for_line(&state, 1), 1); // fn - assert_eq!(suggested_indent_for_line(&state, 2), 2); // 1 + 1 - assert_eq!(suggested_indent_for_line(&state, 4), 1); // } - assert_eq!(suggested_indent_for_line(&state, 5), 0); // } + let state = State::new(doc); + // TODO: set_language + let language_config = crate::syntax::LOADER + .language_config_for_scope("source.rust") + .unwrap(); + let highlight_config = language_config.highlight_config(&[]).unwrap().unwrap(); + let syntax = Syntax::new(&state.doc, highlight_config.clone()); + + assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 0), 0); // mod + assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 1), 1); // fn + assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 2), 2); // 1 + 1 + assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 4), 1); // } + assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 5), 0); // } } } diff --git a/helix-core/src/state.rs b/helix-core/src/state.rs index 75e5cd40e..7fd620a52 100644 --- a/helix-core/src/state.rs +++ b/helix-core/src/state.rs @@ -3,34 +3,11 @@ use crate::syntax::LOADER; use crate::{ChangeSet, Diagnostic, Position, Range, Rope, RopeSlice, Selection, Syntax}; use anyhow::Error; -use std::path::PathBuf; - -#[derive(Copy, Clone, PartialEq, Eq, Hash)] -pub enum Mode { - Normal, - Insert, - Goto, -} - /// A state represents the current editor state of a single buffer. pub struct State { // TODO: fields should be private but we need to refactor commands.rs first - /// Path to file on disk. - pub path: Option, pub doc: Rope, pub selection: Selection, - pub mode: Mode, - - pub restore_cursor: bool, - - // TODO: move these to a Document wrapper? - pub syntax: Option, - /// Pending changes since last history commit. - pub changes: ChangeSet, - pub old_state: Option<(Rope, Selection)>, - - pub version: i64, - pub diagnostics: Vec, } #[derive(Copy, Clone, PartialEq, Eq)] @@ -49,60 +26,12 @@ pub enum Granularity { impl State { #[must_use] pub fn new(doc: Rope) -> Self { - let changes = ChangeSet::new(&doc); - let old_state = Some((doc.clone(), Selection::single(0, 0))); - Self { - path: None, doc, selection: Selection::single(0, 0), - mode: Mode::Normal, - restore_cursor: false, - syntax: None, - changes, - old_state, - diagnostics: Vec::new(), - version: 0, } } - // TODO: passing scopes here is awkward - pub fn load(path: PathBuf, scopes: &[String]) -> Result { - use std::{env, fs::File, io::BufReader}; - let _current_dir = env::current_dir()?; - - let doc = Rope::from_reader(BufReader::new(File::open(path.clone())?))?; - - // TODO: create if not found - - let mut state = Self::new(doc); - - if let Some(language_config) = LOADER.language_config_for_file_name(path.as_path()) { - let highlight_config = language_config.highlight_config(scopes).unwrap().unwrap(); - // TODO: config.configure(scopes) is now delayed, is that ok? - - let syntax = Syntax::new(&state.doc, highlight_config.clone()); - - state.syntax = Some(syntax); - }; - - // canonicalize path to absolute value - state.path = Some(std::fs::canonicalize(path)?); - - Ok(state) - } - - pub fn set_language(&mut self, scope: &str, scopes: &[String]) { - if let Some(language_config) = LOADER.language_config_for_scope(scope) { - let highlight_config = language_config.highlight_config(scopes).unwrap().unwrap(); - // TODO: config.configure(scopes) is now delayed, is that ok? - - let syntax = Syntax::new(&self.doc, highlight_config.clone()); - - self.syntax = Some(syntax); - }; - } - // TODO: doc/selection accessors // TODO: be able to take either Rope or RopeSlice @@ -116,16 +45,6 @@ impl State { &self.selection } - #[inline] - pub fn mode(&self) -> Mode { - self.mode - } - - #[inline] - pub fn path(&self) -> Option<&PathBuf> { - self.path.as_ref() - } - // pub fn doc(&self, range: R) -> RopeSlice // where // R: std::ops::RangeBounds, diff --git a/helix-core/src/syntax.rs b/helix-core/src/syntax.rs index 029036379..f4826fb45 100644 --- a/helix-core/src/syntax.rs +++ b/helix-core/src/syntax.rs @@ -66,7 +66,7 @@ impl LanguageConfiguration { use once_cell::sync::Lazy; -pub(crate) static LOADER: Lazy = Lazy::new(Loader::init); +pub static LOADER: Lazy = Lazy::new(Loader::init); pub struct Loader { // highlight_names ? diff --git a/helix-core/src/transaction.rs b/helix-core/src/transaction.rs index 6f3956aa4..9bd8c6152 100644 --- a/helix-core/src/transaction.rs +++ b/helix-core/src/transaction.rs @@ -351,22 +351,6 @@ pub struct Transaction { // scroll_into_view } -/// Like std::mem::replace() except it allows the replacement value to be mapped from the -/// original value. -pub fn take_with(mut_ref: &mut T, closure: F) -where - F: FnOnce(T) -> T, -{ - use std::{panic, ptr}; - - unsafe { - let old_t = ptr::read(mut_ref); - let new_t = panic::catch_unwind(panic::AssertUnwindSafe(|| closure(old_t))) - .unwrap_or_else(|_| ::std::process::abort()); - ptr::write(mut_ref, new_t); - } -} - impl Transaction { /// Create a new, empty transaction. pub fn new(state: &mut State) -> Self { @@ -376,29 +360,21 @@ impl Transaction { } } + pub fn changes(&self) -> &ChangeSet { + &self.changes + } + /// Returns true if applied successfully. pub fn apply(&self, state: &mut State) -> bool { if !self.changes.is_empty() { - // TODO: also avoid mapping the selection if not necessary - - let old_doc = state.doc().clone(); - // apply changes to the document if !self.changes.apply(&mut state.doc) { return false; } - - // Compose this transaction with the previous one - take_with(&mut state.changes, |changes| { - changes.compose(self.changes.clone()).unwrap() - }); - - if let Some(syntax) = &mut state.syntax { - // TODO: no unwrap - syntax.update(&old_doc, &state.doc, &self.changes).unwrap(); - } } + // TODO: also avoid mapping the selection if not necessary + // update the selection: either take the selection specified in the transaction, or map the // current selection through changes. state.selection = self diff --git a/helix-lsp/Cargo.toml b/helix-lsp/Cargo.toml index e4956f0b6..351c3b0e2 100644 --- a/helix-lsp/Cargo.toml +++ b/helix-lsp/Cargo.toml @@ -8,6 +8,7 @@ edition = "2018" [dependencies] helix-core = { path = "../helix-core" } +helix-view = { path = "../helix-view" } lsp-types = { version = "0.82", features = ["proposed"] } smol = "1.2" diff --git a/helix-lsp/src/client.rs b/helix-lsp/src/client.rs index 93e137cb9..56413768d 100644 --- a/helix-lsp/src/client.rs +++ b/helix-lsp/src/client.rs @@ -6,6 +6,7 @@ use crate::{ type Result = core::result::Result; use helix_core::{State, Transaction}; +use helix_view::Document; // use std::collections::HashMap; @@ -190,13 +191,13 @@ impl Client { // Text document // ------------------------------------------------------------------------------------------- - pub async fn text_document_did_open(&mut self, state: &State) -> Result<()> { + pub async fn text_document_did_open(&mut self, doc: &Document) -> Result<()> { self.notify::(lsp::DidOpenTextDocumentParams { text_document: lsp::TextDocumentItem { - uri: lsp::Url::from_file_path(state.path().unwrap()).unwrap(), + uri: lsp::Url::from_file_path(doc.path().unwrap()).unwrap(), language_id: "rust".to_string(), // TODO: hardcoded for now - version: state.version, - text: String::from(&state.doc), + version: doc.version, + text: String::from(doc.text()), }, }) .await @@ -205,13 +206,13 @@ impl Client { // TODO: trigger any time history.commit_revision happens pub async fn text_document_did_change( &mut self, - state: &State, + doc: &Document, transaction: &Transaction, ) -> Result<()> { self.notify::(lsp::DidChangeTextDocumentParams { text_document: lsp::VersionedTextDocumentIdentifier::new( - lsp::Url::from_file_path(state.path().unwrap()).unwrap(), - state.version, + lsp::Url::from_file_path(doc.path().unwrap()).unwrap(), + doc.version, ), content_changes: vec![lsp::TextDocumentContentChangeEvent { // range = None -> whole document @@ -223,12 +224,12 @@ impl Client { .await } - // TODO: impl into() TextDocumentIdentifier / VersionedTextDocumentIdentifier for State. + // TODO: impl into() TextDocumentIdentifier / VersionedTextDocumentIdentifier for Document. - pub async fn text_document_did_close(&mut self, state: &State) -> Result<()> { + pub async fn text_document_did_close(&mut self, doc: &Document) -> Result<()> { self.notify::(lsp::DidCloseTextDocumentParams { text_document: lsp::TextDocumentIdentifier::new( - lsp::Url::from_file_path(state.path().unwrap()).unwrap(), + lsp::Url::from_file_path(doc.path().unwrap()).unwrap(), ), }) .await diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs index a1a6b9ea7..b9594b7ea 100644 --- a/helix-term/src/application.rs +++ b/helix-term/src/application.rs @@ -1,10 +1,11 @@ use clap::ArgMatches as Args; -use helix_core::{indent::TAB_WIDTH, state::Mode, syntax::HighlightEvent, Position, Range, State}; +use helix_core::{indent::TAB_WIDTH, syntax::HighlightEvent, Position, Range, State}; use helix_view::{ commands, + document::Mode, keymap::{self, Keymaps}, prompt::Prompt, - Editor, Theme, View, + Document, Editor, Theme, View, }; use std::{ @@ -95,15 +96,15 @@ impl Renderer { self.surface.set_style(area, theme.get("ui.background")); // TODO: inefficient, should feed chunks.iter() to tree_sitter.parse_with(|offset, pos|) - let source_code = view.state.doc().to_string(); + let source_code = view.doc.text().to_string(); let last_line = view.last_line(); let range = { // calculate viewport byte ranges - let start = view.state.doc().line_to_byte(view.first_line); - let end = view.state.doc().line_to_byte(last_line) - + view.state.doc().line(last_line).len_bytes(); + let start = view.doc.text().line_to_byte(view.first_line); + let end = view.doc.text().line_to_byte(last_line) + + view.doc.text().line(last_line).len_bytes(); start..end }; @@ -111,7 +112,7 @@ impl Renderer { // TODO: range doesn't actually restrict source, just highlight range // TODO: cache highlight results // TODO: only recalculate when state.doc is actually modified - let highlights: Vec<_> = match view.state.syntax.as_mut() { + let highlights: Vec<_> = match view.doc.syntax.as_mut() { Some(syntax) => { syntax .highlight_iter(source_code.as_bytes(), Some(range), None, |_| None) @@ -127,6 +128,7 @@ impl Renderer { let mut visual_x = 0; let mut line = 0u16; let visible_selections: Vec = view + .doc .state .selection() .ranges() @@ -147,10 +149,10 @@ impl Renderer { HighlightEvent::Source { start, end } => { // TODO: filter out spans out of viewport for now.. - let start = view.state.doc().byte_to_char(start); - let end = view.state.doc().byte_to_char(end); // <-- index 744, len 743 + let start = view.doc.text().byte_to_char(start); + let end = view.doc.text().byte_to_char(end); // <-- index 744, len 743 - let text = view.state.doc().slice(start..end); + let text = view.doc.text().slice(start..end); use helix_core::graphemes::{grapheme_width, RopeGraphemes}; @@ -207,7 +209,7 @@ impl Renderer { // ugh, improve with a traverse method // or interleave highlight spans with selection and diagnostic spans - let style = if view.state.diagnostics.iter().any(|diagnostic| { + let style = if view.doc.diagnostics.iter().any(|diagnostic| { diagnostic.range.0 <= char_index && diagnostic.range.1 > char_index }) { style.clone().add_modifier(Modifier::UNDERLINED) @@ -233,7 +235,7 @@ impl Renderer { let warning: Style = theme.get("warning"); let last_line = view.last_line(); for (i, line) in (view.first_line..last_line).enumerate() { - if view.state.diagnostics.iter().any(|d| d.line == line) { + if view.doc.diagnostics.iter().any(|d| d.line == line) { self.surface.set_stringn(0, i as u16, "●", 1, warning); } @@ -243,7 +245,7 @@ impl Renderer { } pub fn render_statusline(&mut self, view: &View, theme: &Theme) { - let mode = match view.state.mode() { + let mode = match view.doc.mode() { Mode::Insert => "INS", Mode::Normal => "NOR", Mode::Goto => "GOTO", @@ -259,7 +261,7 @@ impl Renderer { self.surface.set_string( self.size.0 - 10, self.size.1 - 2, - format!("{}", view.state.diagnostics.len()), + format!("{}", view.doc.diagnostics.len()), self.text_color, ); } @@ -329,14 +331,14 @@ impl Renderer { pub fn render_cursor(&mut self, view: &View, prompt: Option<&Prompt>, viewport: Rect) { let mut stdout = stdout(); - match view.state.mode() { + match view.doc.mode() { Mode::Insert => write!(stdout, "\x1B[6 q"), mode => write!(stdout, "\x1B[2 q"), }; let pos = if let Some(prompt) = prompt { Position::new(self.size.0 as usize, 2 + prompt.cursor) } else { - if let Some(path) = view.state.path() { + if let Some(path) = view.doc.path() { self.surface.set_string( 6, self.size.1 - 1, @@ -345,10 +347,10 @@ impl Renderer { ); } - let cursor = view.state.selection().cursor(); + let cursor = view.doc.state.selection().cursor(); let mut pos = view - .screen_coords_at_pos(&view.state.doc().slice(..), cursor) + .screen_coords_at_pos(&view.doc.text().slice(..), cursor) .expect("Cursor is out of bounds."); pos.col += viewport.x as usize; pos.row += viewport.y as usize; @@ -416,7 +418,7 @@ impl<'a> Application<'a> { let res = self.lsp.initialize().await; let res = self .lsp - .text_document_did_open(&self.editor.view().unwrap().state) + .text_document_did_open(&self.editor.view().unwrap().doc) .await; self.render(); @@ -469,7 +471,7 @@ impl<'a> Application<'a> { let keys = vec![event]; // TODO: sequences (`gg`) // TODO: handle count other than 1 - match view.state.mode() { + match view.doc.mode() { Mode::Insert => { if let Some(command) = self.keymap[&Mode::Insert].get(&keys) { command(view, 1); @@ -573,10 +575,10 @@ impl<'a> Application<'a> { .editor .views .iter_mut() - .find(|view| view.state.path == path); + .find(|view| view.doc.path == path); if let Some(view) = view { - let doc = view.state.doc().slice(..); + let doc = view.doc.text().slice(..); let diagnostics = params .diagnostics .into_iter() @@ -596,7 +598,7 @@ impl<'a> Application<'a> { }) .collect(); - view.state.diagnostics = diagnostics; + view.doc.diagnostics = diagnostics; self.render(); } diff --git a/helix-view/Cargo.toml b/helix-view/Cargo.toml index 330ae6964..9d53f929d 100644 --- a/helix-view/Cargo.toml +++ b/helix-view/Cargo.toml @@ -19,3 +19,4 @@ helix-core = { path = "../helix-core" } tui = { git = "https://github.com/fdehau/tui-rs", default-features = false, features = ["crossterm"], optional = true} crossterm = { version = "0.18", features = ["event-stream"], optional = true} once_cell = "1.4" +url = "2" diff --git a/helix-view/src/commands.rs b/helix-view/src/commands.rs index e29d070ec..b5350ff46 100644 --- a/helix-view/src/commands.rs +++ b/helix-view/src/commands.rs @@ -3,12 +3,13 @@ use helix_core::{ indent::TAB_WIDTH, regex::Regex, register, selection, - state::{Direction, Granularity, Mode, State}, + state::{Direction, Granularity, State}, ChangeSet, Range, Selection, Tendril, Transaction, }; use once_cell::sync::Lazy; use crate::{ + document::Mode, prompt::Prompt, view::{View, PADDING}, }; @@ -19,36 +20,40 @@ pub type Command = fn(view: &mut View, count: usize); pub fn move_char_left(view: &mut View, count: usize) { // TODO: use a transaction - let selection = view - .state - .move_selection(Direction::Backward, Granularity::Character, count); - view.state.selection = selection; + let selection = + view.doc + .state + .move_selection(Direction::Backward, Granularity::Character, count); + view.doc.state.selection = selection; } pub fn move_char_right(view: &mut View, count: usize) { // TODO: use a transaction - view.state.selection = - view.state + view.doc.state.selection = + view.doc + .state .move_selection(Direction::Forward, Granularity::Character, count); } pub fn move_line_up(view: &mut View, count: usize) { // TODO: use a transaction - view.state.selection = view - .state - .move_selection(Direction::Backward, Granularity::Line, count); + view.doc.state.selection = + view.doc + .state + .move_selection(Direction::Backward, Granularity::Line, count); } pub fn move_line_down(view: &mut View, count: usize) { // TODO: use a transaction - view.state.selection = view - .state - .move_selection(Direction::Forward, Granularity::Line, count); + view.doc.state.selection = + view.doc + .state + .move_selection(Direction::Forward, Granularity::Line, count); } pub fn move_line_end(view: &mut View, _count: usize) { // TODO: use a transaction - let lines = selection_lines(&view.state); + let lines = selection_lines(&view.doc.state); let positions = lines .into_iter() @@ -57,89 +62,89 @@ pub fn move_line_end(view: &mut View, _count: usize) { // Line end is pos at the start of next line - 1 // subtract another 1 because the line ends with \n - view.state.doc.line_to_char(index + 1).saturating_sub(2) + view.doc.text().line_to_char(index + 1).saturating_sub(2) }) .map(|pos| Range::new(pos, pos)); let selection = Selection::new(positions.collect(), 0); - let transaction = Transaction::new(&mut view.state).with_selection(selection); + let transaction = Transaction::new(&mut view.doc.state).with_selection(selection); - transaction.apply(&mut view.state); + view.doc.apply(&transaction); } pub fn move_line_start(view: &mut View, _count: usize) { - let lines = selection_lines(&view.state); + let lines = selection_lines(&view.doc.state); let positions = lines .into_iter() .map(|index| { // adjust all positions to the start of the line. - view.state.doc.line_to_char(index) + view.doc.text().line_to_char(index) }) .map(|pos| Range::new(pos, pos)); let selection = Selection::new(positions.collect(), 0); - let transaction = Transaction::new(&mut view.state).with_selection(selection); + let transaction = Transaction::new(&mut view.doc.state).with_selection(selection); - transaction.apply(&mut view.state); + view.doc.apply(&transaction); } pub fn move_next_word_start(view: &mut View, count: usize) { - let pos = view.state.move_pos( - view.state.selection.cursor(), + let pos = view.doc.state.move_pos( + view.doc.state.selection.cursor(), Direction::Forward, Granularity::Word, count, ); // TODO: use a transaction - view.state.selection = Selection::single(pos, pos); + view.doc.state.selection = Selection::single(pos, pos); } pub fn move_prev_word_start(view: &mut View, count: usize) { - let pos = view.state.move_pos( - view.state.selection.cursor(), + let pos = view.doc.state.move_pos( + view.doc.state.selection.cursor(), Direction::Backward, Granularity::Word, count, ); // TODO: use a transaction - view.state.selection = Selection::single(pos, pos); + view.doc.state.selection = Selection::single(pos, pos); } pub fn move_next_word_end(view: &mut View, count: usize) { let pos = State::move_next_word_end( - &view.state.doc().slice(..), - view.state.selection.cursor(), + &view.doc.text().slice(..), + view.doc.state.selection.cursor(), count, ); // TODO: use a transaction - view.state.selection = Selection::single(pos, pos); + view.doc.state.selection = Selection::single(pos, pos); } pub fn move_file_start(view: &mut View, _count: usize) { // TODO: use a transaction - view.state.selection = Selection::single(0, 0); + view.doc.state.selection = Selection::single(0, 0); - view.state.mode = Mode::Normal; + view.doc.mode = Mode::Normal; } pub fn move_file_end(view: &mut View, _count: usize) { // TODO: use a transaction - let text = &view.state.doc; + let text = &view.doc.text(); let last_line = text.line_to_char(text.len_lines().saturating_sub(2)); - view.state.selection = Selection::single(last_line, last_line); + view.doc.state.selection = Selection::single(last_line, last_line); - view.state.mode = Mode::Normal; + view.doc.mode = Mode::Normal; } pub fn check_cursor_in_view(view: &mut View) -> bool { - let cursor = view.state.selection().cursor(); - let line = view.state.doc().char_to_line(cursor); + let cursor = view.doc.state.selection().cursor(); + let line = view.doc.text().char_to_line(cursor); let document_end = view.first_line + view.size.1.saturating_sub(1) as usize; if (line > document_end.saturating_sub(PADDING)) | (line < view.first_line + PADDING) { @@ -156,19 +161,19 @@ pub fn page_up(view: &mut View, _count: usize) { view.first_line = view.first_line.saturating_sub(view.size.1 as usize); if !check_cursor_in_view(view) { - let text = view.state.doc(); + let text = view.doc.text(); let pos = text.line_to_char(view.last_line().saturating_sub(PADDING)); - view.state.selection = Selection::single(pos, pos); + view.doc.state.selection = Selection::single(pos, pos); } } pub fn page_down(view: &mut View, _count: usize) { view.first_line += view.size.1 as usize + PADDING; - if view.first_line < view.state.doc().len_lines() { - let text = view.state.doc(); + if view.first_line < view.doc.text().len_lines() { + let text = view.doc.text(); let pos = text.line_to_char(view.first_line as usize); - view.state.selection = Selection::single(pos, pos); + view.doc.state.selection = Selection::single(pos, pos); } } @@ -180,79 +185,84 @@ pub fn half_page_up(view: &mut View, _count: usize) { view.first_line = view.first_line.saturating_sub(view.size.1 as usize / 2); if !check_cursor_in_view(view) { - let text = &view.state.doc; + let text = &view.doc.text(); let pos = text.line_to_char(view.last_line() - PADDING); - view.state.selection = Selection::single(pos, pos); + view.doc.state.selection = Selection::single(pos, pos); } } pub fn half_page_down(view: &mut View, _count: usize) { - let lines = view.state.doc().len_lines(); + let lines = view.doc.text().len_lines(); if view.first_line < lines.saturating_sub(view.size.1 as usize) { view.first_line += view.size.1 as usize / 2; } if !check_cursor_in_view(view) { - let text = view.state.doc(); + let text = view.doc.text(); let pos = text.line_to_char(view.first_line as usize); - view.state.selection = Selection::single(pos, pos); + view.doc.state.selection = Selection::single(pos, pos); } } // avoid select by default by having a visual mode switch that makes movements into selects pub fn extend_char_left(view: &mut View, count: usize) { // TODO: use a transaction - let selection = view - .state - .extend_selection(Direction::Backward, Granularity::Character, count); - view.state.selection = selection; + let selection = + view.doc + .state + .extend_selection(Direction::Backward, Granularity::Character, count); + view.doc.state.selection = selection; } pub fn extend_char_right(view: &mut View, count: usize) { // TODO: use a transaction - view.state.selection = - view.state + view.doc.state.selection = + view.doc + .state .extend_selection(Direction::Forward, Granularity::Character, count); } pub fn extend_line_up(view: &mut View, count: usize) { // TODO: use a transaction - view.state.selection = - view.state + view.doc.state.selection = + view.doc + .state .extend_selection(Direction::Backward, Granularity::Line, count); } pub fn extend_line_down(view: &mut View, count: usize) { // TODO: use a transaction - view.state.selection = - view.state + view.doc.state.selection = + view.doc + .state .extend_selection(Direction::Forward, Granularity::Line, count); } pub fn split_selection_on_newline(view: &mut View, _count: usize) { - let text = &view.state.doc.slice(..); + let text = &view.doc.text().slice(..); // only compile the regex once #[allow(clippy::trivial_regex)] static REGEX: Lazy = Lazy::new(|| Regex::new(r"\n").unwrap()); // TODO: use a transaction - view.state.selection = selection::split_on_matches(text, view.state.selection(), ®EX) + view.doc.state.selection = selection::split_on_matches(text, view.doc.state.selection(), ®EX) } pub fn select_line(view: &mut View, _count: usize) { // TODO: count - let pos = view.state.selection().primary(); - let text = view.state.doc(); + let pos = view.doc.state.selection().primary(); + let text = view.doc.text(); let line = text.char_to_line(pos.head); let start = text.line_to_char(line); let end = text.line_to_char(line + 1).saturating_sub(1); // TODO: use a transaction - view.state.selection = Selection::single(start, end); + view.doc.state.selection = Selection::single(start, end); } pub fn delete_selection(view: &mut View, _count: usize) { - let transaction = - Transaction::change_by_selection(&view.state, |range| (range.from(), range.to() + 1, None)); - transaction.apply(&mut view.state); + let transaction = Transaction::change_by_selection(&view.doc.state, |range| { + (range.from(), range.to() + 1, None) + }); + view.doc.apply(&transaction); append_changes_to_history(view); } @@ -263,21 +273,23 @@ pub fn change_selection(view: &mut View, count: usize) { } pub fn collapse_selection(view: &mut View, _count: usize) { - view.state.selection = view + view.doc.state.selection = view + .doc .state .selection .transform(|range| Range::new(range.head, range.head)) } pub fn flip_selections(view: &mut View, _count: usize) { - view.state.selection = view + view.doc.state.selection = view + .doc .state .selection .transform(|range| Range::new(range.head, range.anchor)) } fn enter_insert_mode(view: &mut View) { - view.state.mode = Mode::Insert; + view.doc.mode = Mode::Insert; append_changes_to_history(view); } @@ -285,7 +297,8 @@ fn enter_insert_mode(view: &mut View) { pub fn insert_mode(view: &mut View, _count: usize) { enter_insert_mode(view); - view.state.selection = view + view.doc.state.selection = view + .doc .state .selection .transform(|range| Range::new(range.to(), range.from())) @@ -294,11 +307,11 @@ pub fn insert_mode(view: &mut View, _count: usize) { // inserts at the end of each selection pub fn append_mode(view: &mut View, _count: usize) { enter_insert_mode(view); - view.state.restore_cursor = true; + view.doc.restore_cursor = true; // TODO: as transaction - let text = &view.state.doc.slice(..); - view.state.selection = view.state.selection.transform(|range| { + let text = &view.doc.text().slice(..); + view.doc.state.selection = view.doc.state.selection.transform(|range| { // TODO: to() + next char Range::new( range.from(), @@ -346,13 +359,13 @@ pub fn append_to_line(view: &mut View, count: usize) { pub fn open_below(view: &mut View, _count: usize) { enter_insert_mode(view); - let lines = selection_lines(&view.state); + let lines = selection_lines(&view.doc.state); let positions: Vec<_> = lines .into_iter() .map(|index| { // adjust all positions to the end of the line/start of the next one. - view.state.doc.line_to_char(index + 1) + view.doc.text().line_to_char(index + 1) }) .collect(); @@ -373,63 +386,63 @@ pub fn open_below(view: &mut View, _count: usize) { 0, ); - let transaction = Transaction::change(&view.state, changes).with_selection(selection); + let transaction = Transaction::change(&view.doc.state, changes).with_selection(selection); - transaction.apply(&mut view.state); + view.doc.apply(&transaction); } // O inserts a new line before each line with a selection fn append_changes_to_history(view: &mut View) { - if view.state.changes.is_empty() { + if view.doc.changes.is_empty() { return; } - let new_changeset = ChangeSet::new(view.state.doc()); - let changes = std::mem::replace(&mut view.state.changes, new_changeset); + let new_changeset = ChangeSet::new(view.doc.text()); + let changes = std::mem::replace(&mut view.doc.changes, new_changeset); // Instead of doing this messy merge we could always commit, and based on transaction // annotations either add a new layer or compose into the previous one. - let transaction = Transaction::from(changes).with_selection(view.state.selection().clone()); + let transaction = Transaction::from(changes).with_selection(view.doc.state.selection().clone()); // increment document version // TODO: needs to happen on undo/redo too - view.state.version += 1; + view.doc.version += 1; // TODO: trigger lsp/documentDidChange with changes // HAXX: we need to reconstruct the state as it was before the changes.. - let (doc, selection) = view.state.old_state.take().unwrap(); + let (doc, selection) = view.doc.old_state.take().unwrap(); let mut old_state = State::new(doc); old_state.selection = selection; // TODO: take transaction by value? - view.history.commit_revision(&transaction, &old_state); + view.doc.history.commit_revision(&transaction, &old_state); // HAXX - view.state.old_state = Some((view.state.doc().clone(), view.state.selection.clone())); + view.doc.old_state = Some((view.doc.text().clone(), view.doc.state.selection.clone())); } pub fn normal_mode(view: &mut View, _count: usize) { - view.state.mode = Mode::Normal; + view.doc.mode = Mode::Normal; append_changes_to_history(view); // if leaving append mode, move cursor back by 1 - if view.state.restore_cursor { - let text = &view.state.doc.slice(..); - view.state.selection = view.state.selection.transform(|range| { + if view.doc.restore_cursor { + let text = &view.doc.text().slice(..); + view.doc.state.selection = view.doc.state.selection.transform(|range| { Range::new( range.from(), graphemes::prev_grapheme_boundary(text, range.to()), ) }); - view.state.restore_cursor = false; + view.doc.restore_cursor = false; } } pub fn goto_mode(view: &mut View, _count: usize) { - view.state.mode = Mode::Goto; + view.doc.mode = Mode::Goto; } // NOTE: Transactions in this module get appended to history when we switch back to normal mode. @@ -438,9 +451,9 @@ pub mod insert { // TODO: insert means add text just before cursor, on exit we should be on the last letter. pub fn insert_char(view: &mut View, c: char) { let c = Tendril::from_char(c); - let transaction = Transaction::insert(&view.state, c); + let transaction = Transaction::insert(&view.doc.state, c); - transaction.apply(&mut view.state); + view.doc.apply(&transaction); } pub fn insert_tab(view: &mut View, _count: usize) { @@ -448,41 +461,44 @@ pub mod insert { } pub fn insert_newline(view: &mut View, _count: usize) { - let transaction = Transaction::change_by_selection(&view.state, |range| { - let indent_level = - helix_core::indent::suggested_indent_for_pos(&view.state, range.head); + let transaction = Transaction::change_by_selection(&view.doc.state, |range| { + let indent_level = helix_core::indent::suggested_indent_for_pos( + view.doc.syntax.as_ref(), + &view.doc.state, + range.head, + ); let indent = " ".repeat(TAB_WIDTH).repeat(indent_level); let mut text = String::with_capacity(1 + indent.len()); text.push('\n'); text.push_str(&indent); (range.head, range.head, Some(text.into())) }); - transaction.apply(&mut view.state); + view.doc.apply(&transaction); } // TODO: handle indent-aware delete pub fn delete_char_backward(view: &mut View, count: usize) { - let text = &view.state.doc.slice(..); - let transaction = Transaction::change_by_selection(&view.state, |range| { + let text = &view.doc.text().slice(..); + let transaction = Transaction::change_by_selection(&view.doc.state, |range| { ( graphemes::nth_prev_grapheme_boundary(text, range.head, count), range.head, None, ) }); - transaction.apply(&mut view.state); + view.doc.apply(&transaction); } pub fn delete_char_forward(view: &mut View, count: usize) { - let text = &view.state.doc.slice(..); - let transaction = Transaction::change_by_selection(&view.state, |range| { + let text = &view.doc.text().slice(..); + let transaction = Transaction::change_by_selection(&view.doc.state, |range| { ( range.head, graphemes::nth_next_grapheme_boundary(text, range.head, count), None, ) }); - transaction.apply(&mut view.state); + view.doc.apply(&transaction); } } @@ -493,13 +509,13 @@ pub fn insert_char_prompt(prompt: &mut Prompt, c: char) { // Undo / Redo pub fn undo(view: &mut View, _count: usize) { - view.history.undo(&mut view.state); + view.doc.history.undo(&mut view.doc.state); // TODO: each command could simply return a Option, then the higher level handles storing it? } pub fn redo(view: &mut View, _count: usize) { - view.history.redo(&mut view.state); + view.doc.history.redo(&mut view.doc.state); } // Yank / Paste @@ -507,9 +523,10 @@ pub fn redo(view: &mut View, _count: usize) { pub fn yank(view: &mut View, _count: usize) { // TODO: should selections be made end inclusive? let values = view + .doc .state .selection() - .fragments(&view.state.doc().slice(..)) + .fragments(&view.doc.text().slice(..)) .map(|cow| cow.into_owned()) .collect(); @@ -550,18 +567,18 @@ pub fn paste(view: &mut View, _count: usize) { let transaction = if linewise { // paste on the next line // TODO: can simply take a range + modifier and compute the right pos without ifs - let text = view.state.doc(); - Transaction::change_by_selection(&view.state, |range| { + let text = view.doc.text(); + Transaction::change_by_selection(&view.doc.state, |range| { let line_end = text.line_to_char(text.char_to_line(range.head) + 1); (line_end, line_end, Some(values.next().unwrap())) }) } else { - Transaction::change_by_selection(&view.state, |range| { + Transaction::change_by_selection(&view.doc.state, |range| { (range.head + 1, range.head + 1, Some(values.next().unwrap())) }) }; - transaction.apply(&mut view.state); + view.doc.apply(&transaction); append_changes_to_history(view); } } @@ -570,9 +587,9 @@ fn get_lines(view: &View) -> Vec { let mut lines = Vec::new(); // Get all line numbers - for range in view.state.selection.ranges() { - let start = view.state.doc.char_to_line(range.from()); - let end = view.state.doc.char_to_line(range.to()); + for range in view.doc.state.selection.ranges() { + let start = view.doc.text().char_to_line(range.from()); + let end = view.doc.text().char_to_line(range.to()); for line in start..=end { lines.push(line) @@ -590,13 +607,13 @@ pub fn indent(view: &mut View, _count: usize) { let indent = Tendril::from(" ".repeat(TAB_WIDTH)); let transaction = Transaction::change( - &view.state, + &view.doc.state, lines.into_iter().map(|line| { - let pos = view.state.doc.line_to_char(line); + let pos = view.doc.text().line_to_char(line); (pos, pos, Some(indent.clone())) }), ); - transaction.apply(&mut view.state); + view.doc.apply(&transaction); append_changes_to_history(view); } @@ -605,7 +622,7 @@ pub fn unindent(view: &mut View, _count: usize) { let mut changes = Vec::with_capacity(lines.len()); for line_idx in lines { - let line = view.state.doc.line(line_idx); + let line = view.doc.text().line(line_idx); let mut width = 0; for ch in line.chars() { @@ -621,14 +638,14 @@ pub fn unindent(view: &mut View, _count: usize) { } if width > 0 { - let start = view.state.doc.line_to_char(line_idx); + let start = view.doc.text().line_to_char(line_idx); changes.push((start, start + width, None)) } } - let transaction = Transaction::change(&view.state, changes.into_iter()); + let transaction = Transaction::change(&view.doc.state, changes.into_iter()); - transaction.apply(&mut view.state); + view.doc.apply(&transaction); append_changes_to_history(view); } diff --git a/helix-view/src/document.rs b/helix-view/src/document.rs new file mode 100644 index 000000000..c4b9d0819 --- /dev/null +++ b/helix-view/src/document.rs @@ -0,0 +1,157 @@ +use anyhow::Error; +use std::path::PathBuf; + +use helix_core::{ + syntax::LOADER, ChangeSet, Diagnostic, History, Position, Range, Rope, RopeSlice, Selection, + State, Syntax, Transaction, +}; + +#[derive(Copy, Clone, PartialEq, Eq, Hash)] +pub enum Mode { + Normal, + Insert, + Goto, +} + +pub struct Document { + pub state: State, // rope + selection + /// File path on disk. + pub path: Option, + + /// Current editing mode. + pub mode: Mode, + pub restore_cursor: bool, + + /// Tree-sitter AST tree + pub syntax: Option, + + /// Pending changes since last history commit. + pub changes: ChangeSet, + pub history: History, + pub version: i64, // should be usize? + pub old_state: Option<(Rope, Selection)>, + + pub diagnostics: Vec, +} + +/// Like std::mem::replace() except it allows the replacement value to be mapped from the +/// original value. +fn take_with(mut_ref: &mut T, closure: F) +where + F: FnOnce(T) -> T, +{ + use std::{panic, ptr}; + + unsafe { + let old_t = ptr::read(mut_ref); + let new_t = panic::catch_unwind(panic::AssertUnwindSafe(|| closure(old_t))) + .unwrap_or_else(|_| ::std::process::abort()); + ptr::write(mut_ref, new_t); + } +} + +use url::Url; + +impl Document { + fn new(state: State) -> Self { + let changes = ChangeSet::new(&state.doc); + let old_state = Some((state.doc.clone(), Selection::single(0, 0))); + + Self { + path: None, + state, + mode: Mode::Normal, + restore_cursor: false, + syntax: None, + changes, + old_state, + diagnostics: Vec::new(), + version: 0, + history: History::default(), + } + } + + // TODO: passing scopes here is awkward + pub fn load(path: PathBuf, scopes: &[String]) -> Result { + use std::{env, fs::File, io::BufReader}; + let _current_dir = env::current_dir()?; + + let doc = Rope::from_reader(BufReader::new(File::open(path.clone())?))?; + + // TODO: create if not found + + let mut doc = Self::new(State::new(doc)); + + if let Some(language_config) = LOADER.language_config_for_file_name(path.as_path()) { + let highlight_config = language_config.highlight_config(scopes).unwrap().unwrap(); + // TODO: config.configure(scopes) is now delayed, is that ok? + + let syntax = Syntax::new(&doc.state.doc, highlight_config.clone()); + + doc.syntax = Some(syntax); + }; + + // canonicalize path to absolute value + doc.path = Some(std::fs::canonicalize(path)?); + + Ok(doc) + } + + pub fn set_language(&mut self, scope: &str, scopes: &[String]) { + if let Some(language_config) = LOADER.language_config_for_scope(scope) { + let highlight_config = language_config.highlight_config(scopes).unwrap().unwrap(); + // TODO: config.configure(scopes) is now delayed, is that ok? + + let syntax = Syntax::new(&self.state.doc, highlight_config.clone()); + + self.syntax = Some(syntax); + }; + } + + // TODO: needs to run on undo/redo + pub fn apply(&mut self, transaction: &Transaction) -> bool { + let old_doc = self.text().clone(); + + let success = transaction.apply(&mut self.state); + + if !transaction.changes().is_empty() { + // Compose this transaction with the previous one + take_with(&mut self.changes, |changes| { + changes.compose(transaction.changes().clone()).unwrap() + }); + + // update tree-sitter syntax tree + if let Some(syntax) = &mut self.syntax { + // TODO: no unwrap + syntax + .update(&old_doc, &self.state.doc, transaction.changes()) + .unwrap(); + } + + // TODO: map state.diagnostics over changes::map_pos too + } + success + } + + #[inline] + pub fn mode(&self) -> Mode { + self.mode + } + + #[inline] + pub fn path(&self) -> Option<&PathBuf> { + self.path.as_ref() + } + + pub fn url(&self) -> Option { + self.path().map(|path| Url::from_file_path(path).unwrap()) + } + + pub fn text(&self) -> &Rope { + &self.state.doc + } + + // pub fn slice(&self, range: R) -> RopeSlice where R: RangeBounds { + // self.state.doc.slice + // } +} diff --git a/helix-view/src/editor.rs b/helix-view/src/editor.rs index 61abd4829..02199255c 100644 --- a/helix-view/src/editor.rs +++ b/helix-view/src/editor.rs @@ -1,6 +1,5 @@ use crate::theme::Theme; -use crate::View; -use helix_core::State; +use crate::{Document, View}; use std::path::PathBuf; @@ -27,8 +26,8 @@ impl Editor { pub fn open(&mut self, path: PathBuf, size: (u16, u16)) -> Result<(), Error> { let pos = self.views.len(); - let state = State::load(path, self.theme.scopes())?; - self.views.push(View::new(state, size)?); + let doc = Document::load(path, self.theme.scopes())?; + self.views.push(View::new(doc, size)?); self.focus = pos; Ok(()) } diff --git a/helix-view/src/keymap.rs b/helix-view/src/keymap.rs index 82bdbe21f..347e7d779 100644 --- a/helix-view/src/keymap.rs +++ b/helix-view/src/keymap.rs @@ -1,4 +1,5 @@ use crate::commands::{self, Command}; +use crate::document::Mode; use helix_core::{hashmap, state}; use std::collections::HashMap; @@ -88,7 +89,7 @@ pub use crossterm::event::{KeyCode, KeyEvent as Key, KeyModifiers as Modifiers}; // TODO: could be trie based pub type Keymap = HashMap, Command>; -pub type Keymaps = HashMap; +pub type Keymaps = HashMap; macro_rules! key { ($ch:expr) => { @@ -128,7 +129,7 @@ macro_rules! ctrl { pub fn default() -> Keymaps { hashmap!( - state::Mode::Normal => + Mode::Normal => // as long as you cast the first item, rust is able to infer the other cases hashmap!( vec![key!('h')] => commands::move_char_left as Command, @@ -179,7 +180,7 @@ pub fn default() -> Keymaps { vec![ctrl!('u')] => commands::half_page_up, vec![ctrl!('d')] => commands::half_page_down, ), - state::Mode::Insert => hashmap!( + Mode::Insert => hashmap!( vec![Key { code: KeyCode::Esc, modifiers: Modifiers::NONE @@ -201,7 +202,7 @@ pub fn default() -> Keymaps { modifiers: Modifiers::NONE }] => commands::insert::insert_tab, ), - state::Mode::Goto => hashmap!( + Mode::Goto => hashmap!( vec![Key { code: KeyCode::Esc, modifiers: Modifiers::NONE diff --git a/helix-view/src/lib.rs b/helix-view/src/lib.rs index 9abe8a1aa..3b9237441 100644 --- a/helix-view/src/lib.rs +++ b/helix-view/src/lib.rs @@ -1,10 +1,12 @@ pub mod commands; +pub mod document; pub mod editor; pub mod keymap; pub mod prompt; pub mod theme; pub mod view; +pub use document::Document; pub use editor::Editor; pub use theme::Theme; pub use view::View; diff --git a/helix-view/src/view.rs b/helix-view/src/view.rs index 817714c8e..4cf6a2ee1 100644 --- a/helix-view/src/view.rs +++ b/helix-view/src/view.rs @@ -2,10 +2,11 @@ use anyhow::Error; use std::borrow::Cow; +use crate::Document; use helix_core::{ graphemes::{grapheme_width, RopeGraphemes}, indent::TAB_WIDTH, - History, Position, RopeSlice, State, + Position, RopeSlice, }; use tui::layout::Rect; @@ -14,29 +15,25 @@ pub const PADDING: usize = 5; // TODO: view should be View { doc: Document(state, history,..) } // since we can have multiple views into the same file pub struct View { - pub state: State, + pub doc: Document, pub first_line: usize, pub size: (u16, u16), - - // TODO: Doc fields - pub history: History, } impl View { - pub fn new(state: State, size: (u16, u16)) -> Result { + pub fn new(doc: Document, size: (u16, u16)) -> Result { let view = Self { - state, + doc, first_line: 0, size, - history: History::default(), }; Ok(view) } pub fn ensure_cursor_in_view(&mut self) { - let cursor = self.state.selection().cursor(); - let line = self.state.doc().char_to_line(cursor); + let cursor = self.doc.state.selection().cursor(); + let line = self.doc.text().char_to_line(cursor); let document_end = self.first_line + (self.size.1 as usize).saturating_sub(2); // TODO: side scroll @@ -56,7 +53,7 @@ impl View { let viewport = Rect::new(6, 0, self.size.0, self.size.1 - 2); // - 2 for statusline and prompt std::cmp::min( self.first_line + (viewport.height as usize), - self.state.doc().len_lines() - 1, + self.doc.text().len_lines() - 1, ) } @@ -88,4 +85,25 @@ impl View { Some(Position::new(row, col)) } + + pub fn traverse(&self, text: &RopeSlice, start: usize, end: usize, fun: F) + where + F: Fn(usize, usize), + { + let start = self.screen_coords_at_pos(text, start); + let end = self.screen_coords_at_pos(text, end); + + match (start, end) { + // fully on screen + (Some(start), Some(end)) => { + // we want to calculate ends of lines for each char.. + } + // from start to end of screen + (Some(start), None) => {} + // from start of screen to end + (None, Some(end)) => {} + // not on screen + (None, None) => return, + } + } } From c0e17dd324f016401d56d66b7c113dada0644155 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Hrastnik?= Date: Fri, 23 Oct 2020 11:32:25 +0900 Subject: [PATCH 11/23] Fix undo/redo not updating the syntax tree. --- helix-core/src/history.rs | 46 +++++++++++++++++++++----------------- helix-view/src/commands.rs | 8 +++++-- helix-view/src/document.rs | 1 - 3 files changed, 31 insertions(+), 24 deletions(-) diff --git a/helix-core/src/history.rs b/helix-core/src/history.rs index e6d9a738c..664455251 100644 --- a/helix-core/src/history.rs +++ b/helix-core/src/history.rs @@ -57,37 +57,31 @@ impl History { self.cursor == 0 } - pub fn undo(&mut self, state: &mut State) { + // TODO: I'd like to pass Transaction by reference but it fights with the borrowck + + pub fn undo(&mut self) -> Option { if self.at_root() { // We're at the root of undo, nothing to do. - return; + return None; } let current_revision = &self.revisions[self.cursor]; - // TODO: pass the return value through? It should always succeed - let success = current_revision.revert.apply(state); - - if !success { - panic!("Failed to apply undo!"); - } - self.cursor = current_revision.parent; + + Some(current_revision.revert.clone()) } - pub fn redo(&mut self, state: &mut State) { + pub fn redo(&mut self) -> Option { let current_revision = &self.revisions[self.cursor]; // for now, simply pick the latest child (linear undo / redo) if let Some((index, transaction)) = current_revision.children.last() { - let success = transaction.apply(state); - - if !success { - panic!("Failed to apply redo!"); - } - self.cursor = *index; + + return Some(transaction.clone()); } + None } } @@ -120,17 +114,27 @@ mod test { assert_eq!("hello 世界!", state.doc()); // --- + fn undo(history: &mut History, state: &mut State) { + if let Some(transaction) = history.undo() { + transaction.apply(state); + } + } + fn redo(history: &mut History, state: &mut State) { + if let Some(transaction) = history.redo() { + transaction.apply(state); + } + } - history.undo(&mut state); + undo(&mut history, &mut state); assert_eq!("hello world!", state.doc()); - history.redo(&mut state); + redo(&mut history, &mut state); assert_eq!("hello 世界!", state.doc()); - history.undo(&mut state); - history.undo(&mut state); + undo(&mut history, &mut state); + undo(&mut history, &mut state); assert_eq!("hello", state.doc()); // undo at root is a no-op - history.undo(&mut state); + undo(&mut history, &mut state); assert_eq!("hello", state.doc()); } } diff --git a/helix-view/src/commands.rs b/helix-view/src/commands.rs index b5350ff46..6bf89040f 100644 --- a/helix-view/src/commands.rs +++ b/helix-view/src/commands.rs @@ -509,13 +509,17 @@ pub fn insert_char_prompt(prompt: &mut Prompt, c: char) { // Undo / Redo pub fn undo(view: &mut View, _count: usize) { - view.doc.history.undo(&mut view.doc.state); + if let Some(revert) = view.doc.history.undo() { + view.doc.apply(&revert); + } // TODO: each command could simply return a Option, then the higher level handles storing it? } pub fn redo(view: &mut View, _count: usize) { - view.doc.history.redo(&mut view.doc.state); + if let Some(transaction) = view.doc.history.redo() { + view.doc.apply(&transaction); + } } // Yank / Paste diff --git a/helix-view/src/document.rs b/helix-view/src/document.rs index c4b9d0819..04018ed6a 100644 --- a/helix-view/src/document.rs +++ b/helix-view/src/document.rs @@ -108,7 +108,6 @@ impl Document { }; } - // TODO: needs to run on undo/redo pub fn apply(&mut self, transaction: &Transaction) -> bool { let old_doc = self.text().clone(); From efc5aa2016e56e0721d125a20e3573d25af4dd76 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Hrastnik?= Date: Fri, 23 Oct 2020 11:36:46 +0900 Subject: [PATCH 12/23] Simplify old_state handling. --- helix-core/src/state.rs | 1 + helix-view/src/commands.rs | 8 +------- helix-view/src/document.rs | 4 ++-- 3 files changed, 4 insertions(+), 9 deletions(-) diff --git a/helix-core/src/state.rs b/helix-core/src/state.rs index 7fd620a52..4d531aa02 100644 --- a/helix-core/src/state.rs +++ b/helix-core/src/state.rs @@ -4,6 +4,7 @@ use crate::{ChangeSet, Diagnostic, Position, Range, Rope, RopeSlice, Selection, use anyhow::Error; /// A state represents the current editor state of a single buffer. +#[derive(Clone)] pub struct State { // TODO: fields should be private but we need to refactor commands.rs first pub doc: Rope, diff --git a/helix-view/src/commands.rs b/helix-view/src/commands.rs index 6bf89040f..06c4b9e0d 100644 --- a/helix-view/src/commands.rs +++ b/helix-view/src/commands.rs @@ -411,15 +411,9 @@ fn append_changes_to_history(view: &mut View) { // TODO: trigger lsp/documentDidChange with changes // HAXX: we need to reconstruct the state as it was before the changes.. - let (doc, selection) = view.doc.old_state.take().unwrap(); - let mut old_state = State::new(doc); - old_state.selection = selection; - + let old_state = std::mem::replace(&mut view.doc.old_state, view.doc.state.clone()); // TODO: take transaction by value? view.doc.history.commit_revision(&transaction, &old_state); - - // HAXX - view.doc.old_state = Some((view.doc.text().clone(), view.doc.state.selection.clone())); } pub fn normal_mode(view: &mut View, _count: usize) { diff --git a/helix-view/src/document.rs b/helix-view/src/document.rs index 04018ed6a..22438926e 100644 --- a/helix-view/src/document.rs +++ b/helix-view/src/document.rs @@ -27,9 +27,9 @@ pub struct Document { /// Pending changes since last history commit. pub changes: ChangeSet, + pub old_state: State, pub history: History, pub version: i64, // should be usize? - pub old_state: Option<(Rope, Selection)>, pub diagnostics: Vec, } @@ -55,7 +55,7 @@ use url::Url; impl Document { fn new(state: State) -> Self { let changes = ChangeSet::new(&state.doc); - let old_state = Some((state.doc.clone(), Selection::single(0, 0))); + let old_state = state.clone(); Self { path: None, From e4070d4de0883c3fc979b3d57b1b43ecb0a0d72f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Hrastnik?= Date: Fri, 23 Oct 2020 11:37:32 +0900 Subject: [PATCH 13/23] Bump document version on undo/redo. --- helix-view/src/commands.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/helix-view/src/commands.rs b/helix-view/src/commands.rs index 06c4b9e0d..768a717e5 100644 --- a/helix-view/src/commands.rs +++ b/helix-view/src/commands.rs @@ -504,6 +504,7 @@ pub fn insert_char_prompt(prompt: &mut Prompt, c: char) { pub fn undo(view: &mut View, _count: usize) { if let Some(revert) = view.doc.history.undo() { + view.doc.version += 1; view.doc.apply(&revert); } @@ -512,6 +513,7 @@ pub fn undo(view: &mut View, _count: usize) { pub fn redo(view: &mut View, _count: usize) { if let Some(transaction) = view.doc.history.redo() { + view.doc.version += 1; view.doc.apply(&transaction); } } From 55fa86248c77a01900379ec5bca668978fd5c0d3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Hrastnik?= Date: Fri, 23 Oct 2020 12:06:33 +0900 Subject: [PATCH 14/23] Introduce doc.selection()/set_selection() --- helix-view/src/commands.rs | 142 +++++++++++++++++-------------------- helix-view/src/document.rs | 11 +++ 2 files changed, 78 insertions(+), 75 deletions(-) diff --git a/helix-view/src/commands.rs b/helix-view/src/commands.rs index 768a717e5..d31aed31b 100644 --- a/helix-view/src/commands.rs +++ b/helix-view/src/commands.rs @@ -19,40 +19,38 @@ use crate::{ pub type Command = fn(view: &mut View, count: usize); pub fn move_char_left(view: &mut View, count: usize) { - // TODO: use a transaction let selection = view.doc .state .move_selection(Direction::Backward, Granularity::Character, count); - view.doc.state.selection = selection; + view.doc.set_selection(selection); } pub fn move_char_right(view: &mut View, count: usize) { - // TODO: use a transaction - view.doc.state.selection = + let selection = view.doc .state .move_selection(Direction::Forward, Granularity::Character, count); + view.doc.set_selection(selection); } pub fn move_line_up(view: &mut View, count: usize) { - // TODO: use a transaction - view.doc.state.selection = - view.doc - .state - .move_selection(Direction::Backward, Granularity::Line, count); + let selection = view + .doc + .state + .move_selection(Direction::Backward, Granularity::Line, count); + view.doc.set_selection(selection); } pub fn move_line_down(view: &mut View, count: usize) { - // TODO: use a transaction - view.doc.state.selection = - view.doc - .state - .move_selection(Direction::Forward, Granularity::Line, count); + let selection = view + .doc + .state + .move_selection(Direction::Forward, Granularity::Line, count); + view.doc.set_selection(selection); } pub fn move_line_end(view: &mut View, _count: usize) { - // TODO: use a transaction let lines = selection_lines(&view.doc.state); let positions = lines @@ -68,9 +66,7 @@ pub fn move_line_end(view: &mut View, _count: usize) { let selection = Selection::new(positions.collect(), 0); - let transaction = Transaction::new(&mut view.doc.state).with_selection(selection); - - view.doc.apply(&transaction); + view.doc.set_selection(selection); } pub fn move_line_start(view: &mut View, _count: usize) { @@ -86,64 +82,58 @@ pub fn move_line_start(view: &mut View, _count: usize) { let selection = Selection::new(positions.collect(), 0); - let transaction = Transaction::new(&mut view.doc.state).with_selection(selection); - - view.doc.apply(&transaction); + view.doc.set_selection(selection); } pub fn move_next_word_start(view: &mut View, count: usize) { let pos = view.doc.state.move_pos( - view.doc.state.selection.cursor(), + view.doc.selection().cursor(), Direction::Forward, Granularity::Word, count, ); - // TODO: use a transaction - view.doc.state.selection = Selection::single(pos, pos); + view.doc.set_selection(Selection::single(pos, pos)); } pub fn move_prev_word_start(view: &mut View, count: usize) { let pos = view.doc.state.move_pos( - view.doc.state.selection.cursor(), + view.doc.selection().cursor(), Direction::Backward, Granularity::Word, count, ); - // TODO: use a transaction - view.doc.state.selection = Selection::single(pos, pos); + view.doc.set_selection(Selection::single(pos, pos)); } pub fn move_next_word_end(view: &mut View, count: usize) { let pos = State::move_next_word_end( &view.doc.text().slice(..), - view.doc.state.selection.cursor(), + view.doc.selection().cursor(), count, ); - // TODO: use a transaction - view.doc.state.selection = Selection::single(pos, pos); + view.doc.set_selection(Selection::single(pos, pos)); } pub fn move_file_start(view: &mut View, _count: usize) { - // TODO: use a transaction - view.doc.state.selection = Selection::single(0, 0); + view.doc.set_selection(Selection::single(0, 0)); view.doc.mode = Mode::Normal; } pub fn move_file_end(view: &mut View, _count: usize) { - // TODO: use a transaction let text = &view.doc.text(); let last_line = text.line_to_char(text.len_lines().saturating_sub(2)); - view.doc.state.selection = Selection::single(last_line, last_line); + view.doc + .set_selection(Selection::single(last_line, last_line)); view.doc.mode = Mode::Normal; } pub fn check_cursor_in_view(view: &mut View) -> bool { - let cursor = view.doc.state.selection().cursor(); + let cursor = view.doc.selection().cursor(); let line = view.doc.text().char_to_line(cursor); let document_end = view.first_line + view.size.1.saturating_sub(1) as usize; @@ -163,7 +153,7 @@ pub fn page_up(view: &mut View, _count: usize) { if !check_cursor_in_view(view) { let text = view.doc.text(); let pos = text.line_to_char(view.last_line().saturating_sub(PADDING)); - view.doc.state.selection = Selection::single(pos, pos); + view.doc.set_selection(Selection::single(pos, pos)); } } @@ -173,7 +163,7 @@ pub fn page_down(view: &mut View, _count: usize) { if view.first_line < view.doc.text().len_lines() { let text = view.doc.text(); let pos = text.line_to_char(view.first_line as usize); - view.doc.state.selection = Selection::single(pos, pos); + view.doc.set_selection(Selection::single(pos, pos)); } } @@ -187,7 +177,7 @@ pub fn half_page_up(view: &mut View, _count: usize) { if !check_cursor_in_view(view) { let text = &view.doc.text(); let pos = text.line_to_char(view.last_line() - PADDING); - view.doc.state.selection = Selection::single(pos, pos); + view.doc.set_selection(Selection::single(pos, pos)); } } @@ -199,42 +189,41 @@ pub fn half_page_down(view: &mut View, _count: usize) { if !check_cursor_in_view(view) { let text = view.doc.text(); let pos = text.line_to_char(view.first_line as usize); - view.doc.state.selection = Selection::single(pos, pos); + view.doc.set_selection(Selection::single(pos, pos)); } } // avoid select by default by having a visual mode switch that makes movements into selects pub fn extend_char_left(view: &mut View, count: usize) { - // TODO: use a transaction let selection = view.doc .state .extend_selection(Direction::Backward, Granularity::Character, count); - view.doc.state.selection = selection; + view.doc.set_selection(selection); } pub fn extend_char_right(view: &mut View, count: usize) { - // TODO: use a transaction - view.doc.state.selection = + let selection = view.doc .state .extend_selection(Direction::Forward, Granularity::Character, count); + view.doc.set_selection(selection); } pub fn extend_line_up(view: &mut View, count: usize) { - // TODO: use a transaction - view.doc.state.selection = - view.doc - .state - .extend_selection(Direction::Backward, Granularity::Line, count); + let selection = view + .doc + .state + .extend_selection(Direction::Backward, Granularity::Line, count); + view.doc.set_selection(selection); } pub fn extend_line_down(view: &mut View, count: usize) { - // TODO: use a transaction - view.doc.state.selection = - view.doc - .state - .extend_selection(Direction::Forward, Granularity::Line, count); + let selection = view + .doc + .state + .extend_selection(Direction::Forward, Granularity::Line, count); + view.doc.set_selection(selection); } pub fn split_selection_on_newline(view: &mut View, _count: usize) { @@ -242,20 +231,19 @@ pub fn split_selection_on_newline(view: &mut View, _count: usize) { // only compile the regex once #[allow(clippy::trivial_regex)] static REGEX: Lazy = Lazy::new(|| Regex::new(r"\n").unwrap()); - // TODO: use a transaction - view.doc.state.selection = selection::split_on_matches(text, view.doc.state.selection(), ®EX) + let selection = selection::split_on_matches(text, view.doc.selection(), ®EX); + view.doc.set_selection(selection); } pub fn select_line(view: &mut View, _count: usize) { // TODO: count - let pos = view.doc.state.selection().primary(); + let pos = view.doc.selection().primary(); let text = view.doc.text(); let line = text.char_to_line(pos.head); let start = text.line_to_char(line); let end = text.line_to_char(line + 1).saturating_sub(1); - // TODO: use a transaction - view.doc.state.selection = Selection::single(start, end); + view.doc.set_selection(Selection::single(start, end)); } pub fn delete_selection(view: &mut View, _count: usize) { @@ -273,19 +261,21 @@ pub fn change_selection(view: &mut View, count: usize) { } pub fn collapse_selection(view: &mut View, _count: usize) { - view.doc.state.selection = view + let selection = view .doc - .state - .selection - .transform(|range| Range::new(range.head, range.head)) + .selection() + .transform(|range| Range::new(range.head, range.head)); + + view.doc.set_selection(selection); } pub fn flip_selections(view: &mut View, _count: usize) { - view.doc.state.selection = view + let selection = view .doc - .state - .selection - .transform(|range| Range::new(range.head, range.anchor)) + .selection() + .transform(|range| Range::new(range.head, range.anchor)); + + view.doc.set_selection(selection); } fn enter_insert_mode(view: &mut View) { @@ -297,11 +287,11 @@ fn enter_insert_mode(view: &mut View) { pub fn insert_mode(view: &mut View, _count: usize) { enter_insert_mode(view); - view.doc.state.selection = view + let selection = view .doc - .state - .selection - .transform(|range| Range::new(range.to(), range.from())) + .selection() + .transform(|range| Range::new(range.to(), range.from())); + view.doc.set_selection(selection); } // inserts at the end of each selection @@ -311,13 +301,14 @@ pub fn append_mode(view: &mut View, _count: usize) { // TODO: as transaction let text = &view.doc.text().slice(..); - view.doc.state.selection = view.doc.state.selection.transform(|range| { + let selection = view.doc.selection().transform(|range| { // TODO: to() + next char Range::new( range.from(), graphemes::next_grapheme_boundary(text, range.to()), ) - }) + }); + view.doc.set_selection(selection); } // TODO: I, A, o and O can share a lot of the primitives. @@ -402,7 +393,7 @@ fn append_changes_to_history(view: &mut View) { let changes = std::mem::replace(&mut view.doc.changes, new_changeset); // Instead of doing this messy merge we could always commit, and based on transaction // annotations either add a new layer or compose into the previous one. - let transaction = Transaction::from(changes).with_selection(view.doc.state.selection().clone()); + let transaction = Transaction::from(changes).with_selection(view.doc.selection().clone()); // increment document version // TODO: needs to happen on undo/redo too @@ -424,12 +415,13 @@ pub fn normal_mode(view: &mut View, _count: usize) { // if leaving append mode, move cursor back by 1 if view.doc.restore_cursor { let text = &view.doc.text().slice(..); - view.doc.state.selection = view.doc.state.selection.transform(|range| { + let selection = view.doc.selection().transform(|range| { Range::new( range.from(), graphemes::prev_grapheme_boundary(text, range.to()), ) }); + view.doc.set_selection(selection); view.doc.restore_cursor = false; } @@ -587,7 +579,7 @@ fn get_lines(view: &View) -> Vec { let mut lines = Vec::new(); // Get all line numbers - for range in view.doc.state.selection.ranges() { + for range in view.doc.selection().ranges() { let start = view.doc.text().char_to_line(range.from()); let end = view.doc.text().char_to_line(range.to()); diff --git a/helix-view/src/document.rs b/helix-view/src/document.rs index 22438926e..a313b2812 100644 --- a/helix-view/src/document.rs +++ b/helix-view/src/document.rs @@ -108,6 +108,11 @@ impl Document { }; } + pub fn set_selection(&mut self, selection: Selection) { + // TODO: use a transaction? + self.state.selection = selection; + } + pub fn apply(&mut self, transaction: &Transaction) -> bool { let old_doc = self.text().clone(); @@ -119,6 +124,8 @@ impl Document { changes.compose(transaction.changes().clone()).unwrap() }); + // TODO: when composing, replace transaction.selection too + // update tree-sitter syntax tree if let Some(syntax) = &mut self.syntax { // TODO: no unwrap @@ -150,6 +157,10 @@ impl Document { &self.state.doc } + pub fn selection(&self) -> &Selection { + &self.state.selection + } + // pub fn slice(&self, range: R) -> RopeSlice where R: RangeBounds { // self.state.doc.slice // } From f5981f72c256a834845aad0c2947a4a20fa84d1b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Hrastnik?= Date: Fri, 23 Oct 2020 12:09:40 +0900 Subject: [PATCH 15/23] Introduce Selection::point. --- helix-core/src/selection.rs | 5 +++++ helix-view/src/commands.rs | 19 +++++++++---------- 2 files changed, 14 insertions(+), 10 deletions(-) diff --git a/helix-core/src/selection.rs b/helix-core/src/selection.rs index 13c820f15..9413fead8 100644 --- a/helix-core/src/selection.rs +++ b/helix-core/src/selection.rs @@ -179,6 +179,11 @@ impl Selection { } } + /// Constructs a selection holding a single cursor. + pub fn point(pos: usize) -> Self { + Self::single(pos, pos) + } + #[must_use] pub fn new(ranges: SmallVec<[Range; 1]>, primary_index: usize) -> Self { fn normalize(mut ranges: SmallVec<[Range; 1]>, mut primary_index: usize) -> Selection { diff --git a/helix-view/src/commands.rs b/helix-view/src/commands.rs index d31aed31b..52e09dd67 100644 --- a/helix-view/src/commands.rs +++ b/helix-view/src/commands.rs @@ -93,7 +93,7 @@ pub fn move_next_word_start(view: &mut View, count: usize) { count, ); - view.doc.set_selection(Selection::single(pos, pos)); + view.doc.set_selection(Selection::point(pos)); } pub fn move_prev_word_start(view: &mut View, count: usize) { @@ -104,7 +104,7 @@ pub fn move_prev_word_start(view: &mut View, count: usize) { count, ); - view.doc.set_selection(Selection::single(pos, pos)); + view.doc.set_selection(Selection::point(pos)); } pub fn move_next_word_end(view: &mut View, count: usize) { @@ -114,11 +114,11 @@ pub fn move_next_word_end(view: &mut View, count: usize) { count, ); - view.doc.set_selection(Selection::single(pos, pos)); + view.doc.set_selection(Selection::point(pos)); } pub fn move_file_start(view: &mut View, _count: usize) { - view.doc.set_selection(Selection::single(0, 0)); + view.doc.set_selection(Selection::point(0)); view.doc.mode = Mode::Normal; } @@ -126,8 +126,7 @@ pub fn move_file_start(view: &mut View, _count: usize) { pub fn move_file_end(view: &mut View, _count: usize) { let text = &view.doc.text(); let last_line = text.line_to_char(text.len_lines().saturating_sub(2)); - view.doc - .set_selection(Selection::single(last_line, last_line)); + view.doc.set_selection(Selection::point(last_line)); view.doc.mode = Mode::Normal; } @@ -153,7 +152,7 @@ pub fn page_up(view: &mut View, _count: usize) { if !check_cursor_in_view(view) { let text = view.doc.text(); let pos = text.line_to_char(view.last_line().saturating_sub(PADDING)); - view.doc.set_selection(Selection::single(pos, pos)); + view.doc.set_selection(Selection::point(pos)); } } @@ -163,7 +162,7 @@ pub fn page_down(view: &mut View, _count: usize) { if view.first_line < view.doc.text().len_lines() { let text = view.doc.text(); let pos = text.line_to_char(view.first_line as usize); - view.doc.set_selection(Selection::single(pos, pos)); + view.doc.set_selection(Selection::point(pos)); } } @@ -177,7 +176,7 @@ pub fn half_page_up(view: &mut View, _count: usize) { if !check_cursor_in_view(view) { let text = &view.doc.text(); let pos = text.line_to_char(view.last_line() - PADDING); - view.doc.set_selection(Selection::single(pos, pos)); + view.doc.set_selection(Selection::point(pos)); } } @@ -189,7 +188,7 @@ pub fn half_page_down(view: &mut View, _count: usize) { if !check_cursor_in_view(view) { let text = view.doc.text(); let pos = text.line_to_char(view.first_line as usize); - view.doc.set_selection(Selection::single(pos, pos)); + view.doc.set_selection(Selection::point(pos)); } } // avoid select by default by having a visual mode switch that makes movements into selects From eff6fac9ece0700f0ed8eb0a230b6816fa7cece7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Hrastnik?= Date: Fri, 23 Oct 2020 13:51:08 +0900 Subject: [PATCH 16/23] clippy lint --- helix-lsp/src/transport.rs | 3 +-- helix-view/src/document.rs | 2 ++ helix-view/src/editor.rs | 6 ++++++ helix-view/src/keymap.rs | 2 +- helix-view/src/view.rs | 40 +++++++++++++++++++------------------- 5 files changed, 30 insertions(+), 23 deletions(-) diff --git a/helix-lsp/src/transport.rs b/helix-lsp/src/transport.rs index 38c3bb578..b30a8a6e7 100644 --- a/helix-lsp/src/transport.rs +++ b/helix-lsp/src/transport.rs @@ -138,11 +138,10 @@ impl Transport { // println!("<- {} {:?}", method, notification); self.incoming.send(notification).await?; } - Message::Call(call) => { + Message::Call(_call) => { // println!("<- {:?}", call); // dispatch } - _ => unreachable!(), }; Ok(()) } diff --git a/helix-view/src/document.rs b/helix-view/src/document.rs index a313b2812..710ea4f83 100644 --- a/helix-view/src/document.rs +++ b/helix-view/src/document.rs @@ -164,4 +164,6 @@ impl Document { // pub fn slice(&self, range: R) -> RopeSlice where R: RangeBounds { // self.state.doc.slice // } + + // TODO: transact(Fn) ? } diff --git a/helix-view/src/editor.rs b/helix-view/src/editor.rs index 02199255c..9fb2ae363 100644 --- a/helix-view/src/editor.rs +++ b/helix-view/src/editor.rs @@ -12,6 +12,12 @@ pub struct Editor { pub theme: Theme, // TODO: share one instance } +impl Default for Editor { + fn default() -> Self { + Self::new() + } +} + impl Editor { pub fn new() -> Self { let theme = Theme::default(); diff --git a/helix-view/src/keymap.rs b/helix-view/src/keymap.rs index 347e7d779..aaba34a67 100644 --- a/helix-view/src/keymap.rs +++ b/helix-view/src/keymap.rs @@ -1,6 +1,6 @@ use crate::commands::{self, Command}; use crate::document::Mode; -use helix_core::{hashmap, state}; +use helix_core::hashmap; use std::collections::HashMap; // Kakoune-inspired: diff --git a/helix-view/src/view.rs b/helix-view/src/view.rs index 4cf6a2ee1..df41e3aed 100644 --- a/helix-view/src/view.rs +++ b/helix-view/src/view.rs @@ -86,24 +86,24 @@ impl View { Some(Position::new(row, col)) } - pub fn traverse(&self, text: &RopeSlice, start: usize, end: usize, fun: F) - where - F: Fn(usize, usize), - { - let start = self.screen_coords_at_pos(text, start); - let end = self.screen_coords_at_pos(text, end); - - match (start, end) { - // fully on screen - (Some(start), Some(end)) => { - // we want to calculate ends of lines for each char.. - } - // from start to end of screen - (Some(start), None) => {} - // from start of screen to end - (None, Some(end)) => {} - // not on screen - (None, None) => return, - } - } + // pub fn traverse(&self, text: &RopeSlice, start: usize, end: usize, fun: F) + // where + // F: Fn(usize, usize), + // { + // let start = self.screen_coords_at_pos(text, start); + // let end = self.screen_coords_at_pos(text, end); + + // match (start, end) { + // // fully on screen + // (Some(start), Some(end)) => { + // // we want to calculate ends of lines for each char.. + // } + // // from start to end of screen + // (Some(start), None) => {} + // // from start of screen to end + // (None, Some(end)) => {} + // // not on screen + // (None, None) => return, + // } + // } } From af1924404adac399c351a17bc0f43b5e2889abbb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Hrastnik?= Date: Fri, 23 Oct 2020 14:33:09 +0900 Subject: [PATCH 17/23] Configure logging (-vv for debug level logs) --- Cargo.lock | 68 ++++++++++++++++++++++++++++++++++++-- helix-lsp/Cargo.toml | 7 ++-- helix-lsp/log | 45 ------------------------- helix-lsp/src/transport.rs | 12 ++++--- helix-term/Cargo.toml | 7 +++- helix-term/src/main.rs | 44 ++++++++++++++++++++++++ 6 files changed, 126 insertions(+), 57 deletions(-) delete mode 100644 helix-lsp/log diff --git a/Cargo.lock b/Cargo.lock index 29a86a36c..bc3da508f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -208,6 +208,19 @@ version = "0.1.10" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822" +[[package]] +name = "chrono" +version = "0.4.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "670ad68c9088c2a963aaa298cb369688cf3f9465ce5e2d4ca10e6e0098a1ce73" +dependencies = [ + "libc", + "num-integer", + "num-traits", + "time", + "winapi", +] + [[package]] name = "clap" version = "3.0.0-beta.2" @@ -320,6 +333,15 @@ dependencies = [ "instant", ] +[[package]] +name = "fern" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8c9a4820f0ccc8a7afd67c39a0f1a0f4b07ca1725164271a64939d7aeb9af065" +dependencies = [ + "log", +] + [[package]] name = "futf" version = "0.1.4" @@ -408,7 +430,7 @@ checksum = "fc587bc0ec293155d5bfa6b9891ec18a1e330c234f896ea47fbada4cadbe47e6" dependencies = [ "cfg-if", "libc", - "wasi", + "wasi 0.9.0+wasi-snapshot-preview1", ] [[package]] @@ -449,6 +471,7 @@ dependencies = [ "helix-core", "helix-view", "jsonrpc-core", + "log", "lsp-types", "pathdiff", "serde", @@ -472,12 +495,15 @@ name = "helix-term" version = "0.1.0" dependencies = [ "anyhow", + "chrono", "clap", "crossterm", + "fern", "futures-util", "helix-core", "helix-lsp", "helix-view", + "log", "num_cpus", "smol", "tui", @@ -672,6 +698,25 @@ dependencies = [ "winapi", ] +[[package]] +name = "num-integer" +version = "0.1.43" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8d59457e662d541ba17869cf51cf177c0b5f0cbf476c66bdc90bf1edac4f875b" +dependencies = [ + "autocfg", + "num-traits", +] + +[[package]] +name = "num-traits" +version = "0.2.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac267bcc07f48ee5f8935ab0d24f316fb722d7a1292e2913f0cc196b29ffd611" +dependencies = [ + "autocfg", +] + [[package]] name = "num_cpus" version = "1.13.0" @@ -997,9 +1042,9 @@ dependencies = [ [[package]] name = "syn" -version = "1.0.45" +version = "1.0.46" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ea9c5432ff16d6152371f808fb5a871cd67368171b09bb21b43df8e4a47a3556" +checksum = "5ad5de3220ea04da322618ded2c42233d02baca219d6f160a3e9c87cda16c942" dependencies = [ "proc-macro2", "quote", @@ -1054,6 +1099,17 @@ dependencies = [ "lazy_static", ] +[[package]] +name = "time" +version = "0.1.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6db9e6914ab8b1ae1c260a4ae7a49b6c5611b40328a735b21862567685e73255" +dependencies = [ + "libc", + "wasi 0.10.0+wasi-snapshot-preview1", + "winapi", +] + [[package]] name = "tinyvec" version = "0.3.4" @@ -1160,6 +1216,12 @@ version = "0.9.0+wasi-snapshot-preview1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519" +[[package]] +name = "wasi" +version = "0.10.0+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f" + [[package]] name = "wepoll-sys" version = "3.0.1" diff --git a/helix-lsp/Cargo.toml b/helix-lsp/Cargo.toml index 351c3b0e2..ffd909a4d 100644 --- a/helix-lsp/Cargo.toml +++ b/helix-lsp/Cargo.toml @@ -13,12 +13,13 @@ helix-view = { path = "../helix-view" } lsp-types = { version = "0.82", features = ["proposed"] } smol = "1.2" url = "2" -pathdiff = "0.2.0" -shellexpand = "2.0.0" +pathdiff = "0.2" +shellexpand = "2.0" glob = "0.3" anyhow = "1" serde_json = "1.0" serde = { version = "1.0", features = ["derive"] } jsonrpc-core = "15.1" futures-util = "0.3" -thiserror = "1.0.21" +thiserror = "1" +log = "0.4" diff --git a/helix-lsp/log b/helix-lsp/log deleted file mode 100644 index d8370f16e..000000000 --- a/helix-lsp/log +++ /dev/null @@ -1,45 +0,0 @@ -Sun Oct 18 21:15:33 2020:["lsp#register_server", "server registered", "typescript-language-server"] -Sun Oct 18 21:15:33 2020:["lsp#register_server", "server registered", "elixir-ls"] -Sun Oct 18 21:15:33 2020:["lsp#register_server", "server registered", "vue-language-server"] -Sun Oct 18 21:15:33 2020:["lsp#register_server", "server registered", "rust-analyzer"] -Sun Oct 18 21:15:33 2020:["s:on_text_document_did_open()", 1, "", "/Users/speed/src/helix/helix-lsp", ""] -Sun Oct 18 21:15:34 2020:["s:on_text_document_did_close()", 1] -Sun Oct 18 21:15:34 2020:["s:on_text_document_did_open()", 1, "rust", "/Users/speed/src/helix", "file:///Users/speed/src/helix/helix-lsp/src/lib.rs"] -Sun Oct 18 21:15:34 2020:["Starting server", "rust-analyzer", ["rust-analyzer"]] -Sun Oct 18 21:15:34 2020:[{"response": {"data": {"__data__": "vim-lsp", "lsp_id": 7, "server_name": "rust-analyzer"}, "message": "started lsp server successfully"}}] -Sun Oct 18 21:15:34 2020:["--->", 7, "rust-analyzer", {"method": "initialize", "params": {"rootUri": "file:///Users/speed/src/helix/helix-lsp", "capabilities": {"workspace": {"configuration": true, "applyEdit": true}, "textDocument": {"implementation": {"linkSupport": true}, "documentSymbol": {"symbolKind": {"valueSet": [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "hierarchicalDocumentSymbolSupport": false}, "semanticHighlightingCapabilities": {"semanticHighlighting": false}, "codeAction": {"codeActionLiteralSupport": {"codeActionKind": {"valueSet": ["", "quickfix", "refactor", "refactor.extract", "refactor.inline", "refactor.rewrite", "source", "source.organizeImports"]}}, "dynamicRegistration": false}, "completion": {"completionItem": {"snippetSupport": false, "documentationFormat": ["plaintext"]}, "completionItemKind": {"valueSet": [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 1, 2, 3, 4, 5, 6, 7, 8, 9]}}, "foldingRange": {"lineFoldingOnly": true}, "typeDefinition": {"linkSupport": true}, "typeHierarchy": false, "declaration": {"linkSupport": true}, "definition": {"linkSupport": true}}}, "rootPath": "/Users/speed/src/helix/helix-lsp", "processId": 22973, "trace": "off"}}] -Sun Oct 18 21:15:34 2020:["<---", 7, "rust-analyzer", {"response": {"id": 1, "jsonrpc": "2.0", "result": {"capabilities": {"documentHighlightProvider": true, "hoverProvider": true, "typeDefinitionProvider": true, "workspaceSymbolProvider": true, "referencesProvider": true, "signatureHelpProvider": {"triggerCharacters": ["(", ","]}, "foldingRangeProvider": true, "callHierarchyProvider": true, "codeActionProvider": {"codeActionKinds": ["", "quickfix", "refactor", "refactor.extract", "refactor.inline", "refactor.rewrite"]}, "textDocumentSync": {"save": {}, "change": 2, "openClose": true}, "codeLensProvider": {"resolveProvider": true}, "implementationProvider": true, "documentOnTypeFormattingProvider": {"moreTriggerCharacter": [".", ">"], "firstTriggerCharacter": "="}, "definitionProvider": true, "selectionRangeProvider": true, "semanticTokensProvider": {"legend": {"tokenTypes": ["comment", "keyword", "string", "number", "regexp", "operator", "namespace", "type", "struct", "class", "interface", "enum", "typeParameter", "function", "member", "property", "macro", "variable", "parameter", "label", "attribute", "boolean", "builtinType", "enumMember", "escapeSequence", "formatSpecifier", "generic", "lifetime", "punctuation", "selfKeyword", "typeAlias", "union", "unresolvedReference"], "tokenModifiers": ["documentation", "declaration", "definition", "static", "abstract", "deprecated", "readonly", "constant", "controlFlow", "injected", "mutable", "unsafe", "attribute"]}, "documentProvider": true, "rangeProvider": true}, "documentFormattingProvider": true, "documentSymbolProvider": true, "experimental": {"parentModule": true, "onEnter": true, "runnables": {"kinds": ["cargo"]}, "ssr": true, "joinLines": true}, "renameProvider": {"prepareProvider": true}, "completionProvider": {"triggerCharacters": [":", "."]}}, "serverInfo": {"version": "???????", "name": "rust-analyzer"}}}, "request": {"id": 1, "jsonrpc": "2.0", "method": "initialize", "params": {"rootUri": "file:///Users/speed/src/helix/helix-lsp", "capabilities": {"workspace": {"configuration": true, "applyEdit": true}, "textDocument": {"implementation": {"linkSupport": true}, "documentSymbol": {"symbolKind": {"valueSet": [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "hierarchicalDocumentSymbolSupport": false}, "semanticHighlightingCapabilities": {"semanticHighlighting": false}, "codeAction": {"codeActionLiteralSupport": {"codeActionKind": {"valueSet": ["", "quickfix", "refactor", "refactor.extract", "refactor.inline", "refactor.rewrite", "source", "source.organizeImports"]}}, "dynamicRegistration": false}, "completion": {"completionItem": {"snippetSupport": false, "documentationFormat": ["plaintext"]}, "completionItemKind": {"valueSet": [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 1, 2, 3, 4, 5, 6, 7, 8, 9]}}, "foldingRange": {"lineFoldingOnly": true}, "typeDefinition": {"linkSupport": true}, "typeHierarchy": false, "declaration": {"linkSupport": true}, "definition": {"linkSupport": true}}}, "rootPath": "/Users/speed/src/helix/helix-lsp", "processId": 22973, "trace": "off"}}}] -Sun Oct 18 21:15:34 2020:["--->", 7, "rust-analyzer", {"method": "initialized", "params": {}}] -Sun Oct 18 21:15:34 2020:[{"response": {"data": {"__data__": "vim-lsp", "server_name": "rust-analyzer"}, "message": "configuration sent"}}] -Sun Oct 18 21:15:34 2020:["s:update_file_content()", 1] -Sun Oct 18 21:15:34 2020:["--->", 7, "rust-analyzer", {"method": "textDocument/didOpen", "params": {"textDocument": {"uri": "file:///Users/speed/src/helix/helix-lsp/src/lib.rs", "version": 1, "languageId": "rust", "text": "use std::collections::HashMap;\n\nuse jsonrpc_core as jsonrpc;\nuse lsp_types as lsp;\n\nuse serde::{Deserialize, Serialize};\nuse serde_json::Value;\n\nuse smol::channel::{Receiver, Sender};\nuse smol::io::{BufReader, BufWriter};\nuse smol::prelude::*;\nuse smol::process::{Child, ChildStderr, ChildStdin, ChildStdout, Command, Stdio};\nuse smol::Executor;\n\nuse futures_util::{select, FutureExt};\n\n/// A type representing all possible values sent from the server to the client.\n#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]\n#[serde(deny_unknown_fields)]\n#[serde(untagged)]\nenum Message {\n /// A regular JSON-RPC request output (single response).\n Output(jsonrpc::Output),\n /// A notification.\n Notification(jsonrpc::Notification),\n /// A JSON-RPC request\n Call(jsonrpc::Call),\n}\n\npub struct Client {\n process: Child,\n stderr: BufReader,\n outgoing: Sender,\n\n pub request_counter: u64,\n\n capabilities: Option,\n}\n\nimpl Client {\n pub fn start(ex: &Executor, cmd: &str, args: &[String]) -> Self {\n let mut process = Command::new(cmd)\n .args(args)\n .stdin(Stdio::piped())\n .stdout(Stdio::piped())\n .stderr(Stdio::piped())\n .spawn()\n .expect(\"Failed to start language server\");\n // smol makes sure the process is reaped on drop, but using kill_on_drop(true) maybe?\n\n // TODO: do we need bufreader/writer here? or do we use async wrappers on unblock?\n let writer = BufWriter::new(process.stdin.take().expect(\"Failed to open stdin\"));\n let reader = BufReader::new(process.stdout.take().expect(\"Failed to open stdout\"));\n let stderr = BufReader::new(process.stderr.take().expect(\"Failed to open stderr\"));\n\n let (incoming, outgoing) = Transport::start(ex, reader, writer);\n\n Client {\n process,\n stderr,\n outgoing,\n\n request_counter: 0,\n\n capabilities: None,\n }\n }\n\n fn next_request_id(&mut self) -> jsonrpc::Id {\n let id = jsonrpc::Id::Num(self.request_counter);\n self.request_counter += 1;\n id\n }\n\n fn to_params(value: Value) -> anyhow::Result {\n use jsonrpc::Params;\n\n let params = match value {\n Value::Null => Params::None,\n Value::Bool(_) | Value::Number(_) | Value::String(_) => Params::Array(vec![value]),\n Value::Array(vec) => Params::Array(vec),\n Value::Object(map) => Params::Map(map),\n };\n\n Ok(params)\n }\n\n pub async fn request(\n &mut self,\n params: R::Params,\n ) -> anyhow::Result\n where\n R::Params: serde::Serialize,\n R::Result: core::fmt::Debug, // TODO: temporary\n {\n let params = serde_json::to_value(params)?;\n\n let request = jsonrpc::MethodCall {\n jsonrpc: Some(jsonrpc::Version::V2),\n id: self.next_request_id(),\n method: R::METHOD.to_string(),\n params: Self::to_params(params)?,\n };\n\n let (tx, rx) = smol::channel::bounded::>(1);\n\n self.outgoing\n .send(Payload::Request {\n chan: tx,\n value: request,\n })\n .await?;\n\n let response = rx.recv().await??;\n\n let response = serde_json::from_value(response)?;\n\n // TODO: we should pass request to a sender thread via a channel\n // so it can't be interleaved\n\n // TODO: responses can be out of order, we need to register a single shot response channel\n\n Ok(response)\n }\n\n pub async fn notify(\n &mut self,\n params: R::Params,\n ) -> anyhow::Result<()>\n where\n R::Params: serde::Serialize,\n {\n let params = serde_json::to_value(params)?;\n\n let notification = jsonrpc::Notification {\n jsonrpc: Some(jsonrpc::Version::V2),\n method: R::METHOD.to_string(),\n params: Self::to_params(params)?,\n };\n\n self.outgoing\n .send(Payload::Notification(notification))\n .await?;\n\n Ok(())\n }\n\n // -------------------------------------------------------------------------------------------\n // General messages\n // -------------------------------------------------------------------------------------------\n\n pub async fn initialize(&mut self) -> anyhow::Result<()> {\n // TODO: delay any requests that are triggered prior to initialize\n\n #[allow(deprecated)]\n let params = lsp::InitializeParams {\n process_id: Some(u64::from(std::process::id())),\n root_path: None,\n // root_uri: Some(lsp_types::Url::parse(\"file://localhost/\")?),\n root_uri: None, // set to project root in the future\n initialization_options: None,\n capabilities: lsp::ClientCapabilities::default(),\n trace: None,\n workspace_folders: None,\n client_info: None,\n };\n\n let response = self.request::(params).await?;\n self.capabilities = Some(response.capabilities);\n\n // next up, notify\n self.notify::(lsp::InitializedParams {})\n .await?;\n\n Ok(())\n }\n\n pub async fn shutdown(&mut self) -> anyhow::Result<()> {\n self.request::(()).await\n }\n\n pub async fn exit(&mut self) -> anyhow::Result<()> {\n self.notify::(()).await\n }\n\n // -------------------------------------------------------------------------------------------\n // Text document\n // -------------------------------------------------------------------------------------------\n\n pub async fn text_document_did_open(\n &mut self,\n state: &helix_core::State,\n ) -> anyhow::Result<()> {\n self.notify::(lsp::DidOpenTextDocumentParams {\n text_document: lsp::TextDocumentItem {\n uri: lsp::Url::from_file_path(\n std::fs::canonicalize(state.path.as_ref().unwrap()).unwrap(),\n )\n .unwrap(),\n language_id: \"rust\".to_string(), // TODO: hardcoded for now\n version: 0,\n text: String::from(&state.doc),\n },\n })\n .await\n }\n\n // TODO: trigger any time history.commit_revision happens\n pub async fn text_document_did_change(\n &mut self,\n state: &helix_core::State,\n ) -> anyhow::Result<()> {\n self.notify::(lsp::DidSaveTextDocumentParams {\n text_document: lsp::TextDocumentIdentifier::new(\n lsp::Url::from_file_path(state.path.as_ref().unwrap()).unwrap(),\n ),\n text: None, // TODO?\n })\n .await\n }\n\n pub async fn text_document_did_close(&mut self) -> anyhow::Result<()> {\n unimplemented!()\n }\n\n // will_save / will_save_wait_until\n\n pub async fn text_document_did_save(&mut self) -> anyhow::Result<()> {\n unimplemented!()\n }\n}\n\nenum Payload {\n Request {\n chan: Sender>,\n value: jsonrpc::MethodCall,\n },\n Notification(jsonrpc::Notification),\n}\n\nstruct Transport {\n incoming: Sender,\n outgoing: Receiver,\n\n pending_requests: HashMap>>,\n headers: HashMap,\n\n writer: BufWriter,\n reader: BufReader,\n}\n\nimpl Transport {\n pub fn start(\n ex: &Executor,\n reader: BufReader,\n writer: BufWriter,\n ) -> (Receiver, Sender) {\n let (incoming, rx) = smol::channel::unbounded();\n let (tx, outgoing) = smol::channel::unbounded();\n\n let transport = Self {\n reader,\n writer,\n incoming,\n outgoing,\n pending_requests: Default::default(),\n headers: Default::default(),\n };\n\n ex.spawn(transport.duplex()).detach();\n\n (rx, tx)\n }\n\n async fn recv(\n reader: &mut (impl AsyncBufRead + Unpin),\n headers: &mut HashMap,\n ) -> Result {\n // read headers\n loop {\n let mut header = String::new();\n // detect pipe closed if 0\n reader.read_line(&mut header).await?;\n let header = header.trim();\n\n if header.is_empty() {\n break;\n }\n\n let parts: Vec<&str> = header.split(\": \").collect();\n if parts.len() != 2 {\n // return Err(Error::new(ErrorKind::Other, \"Failed to parse header\"));\n panic!()\n }\n headers.insert(parts[0].to_string(), parts[1].to_string());\n }\n\n // find content-length\n let content_length = headers.get(\"Content-Length\").unwrap().parse().unwrap();\n\n let mut content = vec![0; content_length];\n reader.read_exact(&mut content).await?;\n let msg = String::from_utf8(content).unwrap();\n\n // read data\n\n // try parsing as output (server response) or call (server request)\n let output: serde_json::Result = serde_json::from_str(&msg);\n\n Ok(output?)\n }\n\n pub async fn send_payload(&mut self, payload: Payload) -> anyhow::Result<()> {\n match payload {\n Payload::Request { chan, value } => {\n self.pending_requests.insert(value.id.clone(), chan);\n\n let json = serde_json::to_string(&value)?;\n self.send(json).await\n }\n Payload::Notification(value) => {\n let json = serde_json::to_string(&value)?;\n self.send(json).await\n }\n }\n }\n\n pub async fn send(&mut self, request: String) -> anyhow::Result<()> {\n println!(\"-> {}\", request);\n\n // send the headers\n self.writer\n .write_all(format!(\"Content-Length: {}\\r\\n\\r\\n\", request.len()).as_bytes())\n .await?;\n\n // send the body\n self.writer.write_all(request.as_bytes()).await?;\n\n self.writer.flush().await?;\n\n Ok(())\n }\n\n pub async fn recv_response(&mut self, output: jsonrpc::Output) -> anyhow::Result<()> {\n match output {\n jsonrpc::Output::Success(jsonrpc::Success { id, result, .. }) => {\n println!(\"<- {}\", result);\n\n let tx = self\n .pending_requests\n .remove(&id)\n .expect(\"pending_request with id not found!\");\n tx.send(Ok(result)).await?;\n }\n jsonrpc::Output::Failure(_) => panic!(\"recv fail\"),\n msg => unimplemented!(\"{:?}\", msg),\n }\n Ok(())\n }\n\n pub async fn duplex(mut self) {\n loop {\n select! {\n // client -> server\n msg = self.outgoing.next().fuse() => {\n if msg.is_none() {\n break;\n }\n let msg = msg.unwrap();\n\n self.send_payload(msg).await.unwrap();\n }\n // server <- client\n msg = Self::recv(&mut self.reader, &mut self.headers).fuse() => {\n if msg.is_err() {\n break;\n }\n let msg = msg.unwrap();\n\n match msg {\n Message::Output(output) => self.recv_response(output).await.unwrap(),\n Message::Notification(_) => {\n // dispatch\n }\n Message::Call(_) => {\n // dispatch\n }\n };\n }\n }\n }\n }\n}\n"}}}] -Sun Oct 18 21:15:34 2020:[{"response": {"data": {"__data__": "vim-lsp", "server_name": "rust-analyzer"}, "message": "server already started"}}] -Sun Oct 18 21:15:34 2020:[{"response": {"data": {"__data__": "vim-lsp", "init_result": {"id": 1, "jsonrpc": "2.0", "result": {"capabilities": {"documentHighlightProvider": true, "hoverProvider": true, "typeDefinitionProvider": true, "workspaceSymbolProvider": true, "referencesProvider": true, "signatureHelpProvider": {"triggerCharacters": ["(", ","]}, "foldingRangeProvider": true, "callHierarchyProvider": true, "codeActionProvider": {"codeActionKinds": ["", "quickfix", "refactor", "refactor.extract", "refactor.inline", "refactor.rewrite"]}, "textDocumentSync": {"save": {}, "change": 2, "openClose": true}, "codeLensProvider": {"resolveProvider": true}, "implementationProvider": true, "documentOnTypeFormattingProvider": {"moreTriggerCharacter": [".", ">"], "firstTriggerCharacter": "="}, "definitionProvider": true, "selectionRangeProvider": true, "semanticTokensProvider": {"legend": {"tokenTypes": ["comment", "keyword", "string", "number", "regexp", "operator", "namespace", "type", "struct", "class", "interface", "enum", "typeParameter", "function", "member", "property", "macro", "variable", "parameter", "label", "attribute", "boolean", "builtinType", "enumMember", "escapeSequence", "formatSpecifier", "generic", "lifetime", "punctuation", "selfKeyword", "typeAlias", "union", "unresolvedReference"], "tokenModifiers": ["documentation", "declaration", "definition", "static", "abstract", "deprecated", "readonly", "constant", "controlFlow", "injected", "mutable", "unsafe", "attribute"]}, "documentProvider": true, "rangeProvider": true}, "documentFormattingProvider": true, "documentSymbolProvider": true, "experimental": {"parentModule": true, "onEnter": true, "runnables": {"kinds": ["cargo"]}, "ssr": true, "joinLines": true}, "renameProvider": {"prepareProvider": true}, "completionProvider": {"triggerCharacters": [":", "."]}}, "serverInfo": {"version": "???????", "name": "rust-analyzer"}}}, "server_name": "rust-analyzer"}, "message": "lsp server already initialized"}}] -Sun Oct 18 21:15:34 2020:[{"response": {"data": {"__data__": "vim-lsp", "server_name": "rust-analyzer"}, "message": "configuration sent"}}] -Sun Oct 18 21:15:34 2020:[{"response": {"data": {"path": "file:///Users/speed/src/helix/helix-lsp/src/lib.rs", "__data__": "vim-lsp", "server_name": "rust-analyzer"}, "message": "already opened"}}] -Sun Oct 18 21:15:34 2020:[{"response": {"data": {"path": "file:///Users/speed/src/helix/helix-lsp/src/lib.rs", "__data__": "vim-lsp", "server_name": "rust-analyzer"}, "message": "not dirty"}}] -Sun Oct 18 21:15:34 2020:["--->", 7, "rust-analyzer", {"method": "textDocument/foldingRange", "on_notification": "---funcref---", "bufnr": 1, "params": {"textDocument": {"uri": "file:///Users/speed/src/helix/helix-lsp/src/lib.rs"}}, "sync": 0}] -Sun Oct 18 21:15:34 2020:[{"response": {"data": {"path": "file:///Users/speed/src/helix/helix-lsp/src/lib.rs", "__data__": "vim-lsp", "filetype": "rust", "server_name": "rust-analyzer"}, "message": "textDocument/open sent"}}] -Sun Oct 18 21:15:34 2020:[{"response": {"data": {"path": "file:///Users/speed/src/helix/helix-lsp/src/lib.rs", "__data__": "vim-lsp", "server_name": "rust-analyzer"}, "message": "not dirty"}}] -Sun Oct 18 21:15:35 2020:["<---", 7, {"id": 0, "jsonrpc": "2.0", "method": "client/registerCapability", "params": {"registrations": [{"id": "textDocument/didSave", "registerOptions": {"includeText": false, "documentSelector": [{"pattern": "**/*.rs"}, {"pattern": "**/Cargo.toml"}, {"pattern": "**/Cargo.lock"}]}, "method": "textDocument/didSave"}]}}] -Sun Oct 18 21:15:35 2020:["--->", 7, "rust-analyzer", {"id": 0, "error": {"code": -32601, "message": "Method not found"}}] -Sun Oct 18 21:15:35 2020:["<---", 7, "rust-analyzer", {"response": {"id": 2, "jsonrpc": "2.0", "result": [{"startLine": 2, "kind": "imports", "endLine": 3}, {"startLine": 5, "kind": "imports", "endLine": 6}, {"startLine": 8, "kind": "imports", "endLine": 12}, {"startLine": 20, "endLine": 27}, {"startLine": 29, "endLine": 37}, {"startLine": 39, "endLine": 230}, {"startLine": 40, "endLine": 66}, {"startLine": 57, "endLine": 65}, {"startLine": 68, "endLine": 72}, {"startLine": 74, "endLine": 85}, {"startLine": 77, "endLine": 81}, {"startLine": 87, "endLine": 89}, {"startLine": 94, "endLine": 123}, {"startLine": 97, "endLine": 101}, {"startLine": 107, "endLine": 110}, {"startLine": 107, "endLine": 109}, {"startLine": 117, "kind": "comment", "endLine": 118}, {"startLine": 125, "endLine": 127}, {"startLine": 131, "endLine": 145}, {"startLine": 134, "endLine": 137}, {"startLine": 147, "kind": "comment", "endLine": 149}, {"startLine": 151, "endLine": 175}, {"startLine": 155, "endLine": 164}, {"startLine": 177, "endLine": 179}, {"startLine": 181, "endLine": 183}, {"startLine": 185, "kind": "comment", "endLine": 187}, {"startLine": 189, "endLine": 191}, {"startLine": 192, "endLine": 205}, {"startLine": 193, "endLine": 203}, {"startLine": 193, "endLine": 202}, {"startLine": 194, "endLine": 201}, {"startLine": 195, "endLine": 197}, {"startLine": 208, "endLine": 210}, {"startLine": 211, "endLine": 219}, {"startLine": 212, "endLine": 217}, {"startLine": 212, "endLine": 216}, {"startLine": 213, "endLine": 214}, {"startLine": 221, "endLine": 223}, {"startLine": 227, "endLine": 229}, {"startLine": 232, "endLine": 238}, {"startLine": 233, "endLine": 235}, {"startLine": 240, "endLine": 249}, {"startLine": 251, "endLine": 392}, {"startLine": 252, "endLine": 255}, {"startLine": 256, "endLine": 272}, {"startLine": 260, "endLine": 266}, {"startLine": 274, "endLine": 276}, {"startLine": 277, "endLine": 310}, {"startLine": 279, "endLine": 295}, {"startLine": 285, "endLine": 287}, {"startLine": 290, "endLine": 293}, {"startLine": 312, "endLine": 325}, {"startLine": 313, "endLine": 324}, {"startLine": 314, "endLine": 319}, {"startLine": 320, "endLine": 323}, {"startLine": 327, "endLine": 341}, {"startLine": 343, "endLine": 358}, {"startLine": 344, "endLine": 356}, {"startLine": 345, "endLine": 353}, {"startLine": 360, "endLine": 391}, {"startLine": 361, "endLine": 390}, {"startLine": 362, "endLine": 389}, {"startLine": 364, "endLine": 371}, {"startLine": 365, "endLine": 367}, {"startLine": 373, "endLine": 388}, {"startLine": 374, "endLine": 376}, {"startLine": 379, "endLine": 386}, {"startLine": 381, "endLine": 383}, {"startLine": 384, "endLine": 386}]}, "request": {"id": 2, "jsonrpc": "2.0", "method": "textDocument/foldingRange", "params": {"textDocument": {"uri": "file:///Users/speed/src/helix/helix-lsp/src/lib.rs"}}}}] -Sun Oct 18 21:15:36 2020:["<---", 7, "rust-analyzer", {"response": {"method": "textDocument/publishDiagnostics", "jsonrpc": "2.0", "params": {"diagnostics": [{"source": "rustc", "range": {"end": {"character": 15, "line": 355}, "start": {"character": 12, "line": 355}}, "code": "unreachable_patterns", "message": "unreachable pattern\n`#[warn(unreachable_patterns)]` on by default", "severity": 2}], "uri": "file:///Users/speed/src/helix/helix-lsp/src/lib.rs", "version": 1}}}] -Sun Oct 18 21:15:36 2020:["<---", 7, "rust-analyzer", {"response": {"method": "textDocument/publishDiagnostics", "jsonrpc": "2.0", "params": {"diagnostics": [{"source": "rustc", "tags": [1], "range": {"end": {"character": 28, "line": 618}, "start": {"character": 24, "line": 618}}, "code": "unused_variables", "message": "unused variable: `view`\n`#[warn(unused_variables)]` on by default", "severity": 2}], "uri": "file:///Users/speed/src/helix/helix-view/src/commands.rs"}}}] -Sun Oct 18 21:15:36 2020:["<---", 7, "rust-analyzer", {"response": {"method": "textDocument/publishDiagnostics", "jsonrpc": "2.0", "params": {"diagnostics": [{"source": "rustc", "range": {"end": {"character": 15, "line": 355}, "start": {"character": 12, "line": 355}}, "code": "unreachable_patterns", "message": "unreachable pattern\n`#[warn(unreachable_patterns)]` on by default", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 21, "line": 55}, "start": {"character": 13, "line": 55}}, "code": "unused_variables", "message": "unused variable: `incoming`\n`#[warn(unused_variables)]` on by default", "severity": 2}], "uri": "file:///Users/speed/src/helix/helix-lsp/src/lib.rs", "version": 1}}}] -Sun Oct 18 21:15:36 2020:["<---", 7, "rust-analyzer", {"response": {"method": "textDocument/publishDiagnostics", "jsonrpc": "2.0", "params": {"diagnostics": [{"source": "rustc", "range": {"end": {"character": 15, "line": 355}, "start": {"character": 12, "line": 355}}, "code": "unreachable_patterns", "message": "unreachable pattern\n`#[warn(unreachable_patterns)]` on by default", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 21, "line": 55}, "start": {"character": 13, "line": 55}}, "code": "unused_variables", "message": "unused variable: `incoming`\n`#[warn(unused_variables)]` on by default", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 18, "line": 30}, "start": {"character": 4, "line": 30}}, "code": "dead_code", "message": "field is never read: `process`\n`#[warn(dead_code)]` on by default", "severity": 2}], "uri": "file:///Users/speed/src/helix/helix-lsp/src/lib.rs", "version": 1}}}] -Sun Oct 18 21:15:36 2020:["<---", 7, "rust-analyzer", {"response": {"method": "textDocument/publishDiagnostics", "jsonrpc": "2.0", "params": {"diagnostics": [{"source": "rustc", "range": {"end": {"character": 15, "line": 355}, "start": {"character": 12, "line": 355}}, "code": "unreachable_patterns", "message": "unreachable pattern\n`#[warn(unreachable_patterns)]` on by default", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 21, "line": 55}, "start": {"character": 13, "line": 55}}, "code": "unused_variables", "message": "unused variable: `incoming`\n`#[warn(unused_variables)]` on by default", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 18, "line": 30}, "start": {"character": 4, "line": 30}}, "code": "dead_code", "message": "field is never read: `process`\n`#[warn(dead_code)]` on by default", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 34, "line": 31}, "start": {"character": 4, "line": 31}}, "code": "dead_code", "message": "field is never read: `stderr`", "severity": 2}], "uri": "file:///Users/speed/src/helix/helix-lsp/src/lib.rs", "version": 1}}}] -Sun Oct 18 21:15:36 2020:["<---", 7, "rust-analyzer", {"response": {"method": "textDocument/publishDiagnostics", "jsonrpc": "2.0", "params": {"diagnostics": [{"source": "rustc", "range": {"end": {"character": 15, "line": 355}, "start": {"character": 12, "line": 355}}, "code": "unreachable_patterns", "message": "unreachable pattern\n`#[warn(unreachable_patterns)]` on by default", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 21, "line": 55}, "start": {"character": 13, "line": 55}}, "code": "unused_variables", "message": "unused variable: `incoming`\n`#[warn(unused_variables)]` on by default", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 18, "line": 30}, "start": {"character": 4, "line": 30}}, "code": "dead_code", "message": "field is never read: `process`\n`#[warn(dead_code)]` on by default", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 34, "line": 31}, "start": {"character": 4, "line": 31}}, "code": "dead_code", "message": "field is never read: `stderr`", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 29, "line": 241}, "start": {"character": 4, "line": 241}}, "code": "dead_code", "message": "field is never read: `incoming`", "severity": 2}], "uri": "file:///Users/speed/src/helix/helix-lsp/src/lib.rs", "version": 1}}}] -Sun Oct 18 21:15:39 2020:["lsp#register_server", "server registered", "typescript-language-server"] -Sun Oct 18 21:15:39 2020:["lsp#register_server", "server registered", "elixir-ls"] -Sun Oct 18 21:15:39 2020:["lsp#register_server", "server registered", "vue-language-server"] -Sun Oct 18 21:15:39 2020:["lsp#register_server", "server registered", "rust-analyzer"] -Sun Oct 18 21:15:39 2020:["s:on_text_document_did_open()", 1, "vim", "/Users/speed/src/helix/helix-lsp", "file:///Users/speed/.vimrc"] -Sun Oct 18 21:15:40 2020:["s:on_text_document_did_change()", 1] -Sun Oct 18 21:15:40 2020:["s:send_didchange_queue() will be triggered"] -Sun Oct 18 21:15:40 2020:["s:on_text_document_did_change()", 1] -Sun Oct 18 21:15:41 2020:["s:on_text_document_did_save()", 1] -Sun Oct 18 21:15:41 2020:["s:on_text_document_did_close()", 1] -Sun Oct 18 21:15:55 2020:["<---", 7, "rust-analyzer", {"response": {"method": "textDocument/publishDiagnostics", "jsonrpc": "2.0", "params": {"diagnostics": [{"source": "rustc", "range": {"end": {"character": 15, "line": 355}, "start": {"character": 12, "line": 355}}, "code": "unreachable_patterns", "message": "unreachable pattern\n`#[warn(unreachable_patterns)]` on by default", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 21, "line": 55}, "start": {"character": 13, "line": 55}}, "code": "unused_variables", "message": "unused variable: `incoming`\n`#[warn(unused_variables)]` on by default", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 18, "line": 30}, "start": {"character": 4, "line": 30}}, "code": "dead_code", "message": "field is never read: `process`\n`#[warn(dead_code)]` on by default", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 34, "line": 31}, "start": {"character": 4, "line": 31}}, "code": "dead_code", "message": "field is never read: `stderr`", "severity": 2}, {"source": "rustc", "tags": [1], "range": {"end": {"character": 29, "line": 241}, "start": {"character": 4, "line": 241}}, "code": "dead_code", "message": "field is never read: `incoming`", "severity": 2}], "uri": "file:///Users/speed/src/helix/helix-lsp/src/lib.rs", "version": 1}}}] -Sun Oct 18 21:15:57 2020:["s:on_text_document_did_close()", 1] -Sun Oct 18 21:15:57 2020:["s:on_exit", 7, "rust-analyzer", "exited", 143] diff --git a/helix-lsp/src/transport.rs b/helix-lsp/src/transport.rs index b30a8a6e7..4ab3d5ecf 100644 --- a/helix-lsp/src/transport.rs +++ b/helix-lsp/src/transport.rs @@ -1,5 +1,7 @@ use std::collections::HashMap; +use log::debug; + use crate::{Error, Message, Notification}; type Result = core::result::Result; @@ -114,7 +116,7 @@ impl Transport { } pub async fn send(&mut self, request: String) -> anyhow::Result<()> { - // println!("-> {}", request); + debug!("-> {}", request); // send the headers self.writer @@ -135,11 +137,11 @@ impl Transport { Message::Notification(jsonrpc::Notification { method, params, .. }) => { let notification = Notification::parse(&method, params); - // println!("<- {} {:?}", method, notification); + debug!("<- {} {:?}", method, notification); self.incoming.send(notification).await?; } - Message::Call(_call) => { - // println!("<- {:?}", call); + Message::Call(call) => { + debug!("<- {:?}", call); // dispatch } }; @@ -149,7 +151,7 @@ impl Transport { pub async fn recv_response(&mut self, output: jsonrpc::Output) -> anyhow::Result<()> { match output { jsonrpc::Output::Success(jsonrpc::Success { id, result, .. }) => { - // println!("<- {}", result); + debug!("<- {}", result); let tx = self .pending_requests diff --git a/helix-term/Cargo.toml b/helix-term/Cargo.toml index db1edee97..c1560ee7d 100644 --- a/helix-term/Cargo.toml +++ b/helix-term/Cargo.toml @@ -19,10 +19,15 @@ helix-lsp = { path = "../helix-lsp"} anyhow = "1" smol = "1" -num_cpus = "1.13" +num_cpus = "1" # tui = { version = "0.12", default-features = false, features = ["crossterm"] } tui = { git = "https://github.com/fdehau/tui-rs", default-features = false, features = ["crossterm"] } crossterm = { version = "0.18", features = ["event-stream"] } clap = { version = "3.0.0-beta.2 ", default-features = false, features = ["std", "cargo"] } futures-util = "0.3" + +# Logging +fern = "0.6" +chrono = "0.4" +log = "0.4" diff --git a/helix-term/src/main.rs b/helix-term/src/main.rs index de3a01755..f91c1c8f4 100644 --- a/helix-term/src/main.rs +++ b/helix-term/src/main.rs @@ -11,6 +11,39 @@ use anyhow::Error; static EX: smol::Executor = smol::Executor::new(); +fn setup_logging(verbosity: u64) -> Result<(), fern::InitError> { + let mut base_config = fern::Dispatch::new(); + + // Let's say we depend on something which whose "info" level messages are too + // verbose to include in end-user output. If we don't need them, + // let's not include them. + // .level_for("overly-verbose-target", log::LevelFilter::Warn) + + base_config = match verbosity { + 0 => base_config.level(log::LevelFilter::Warn), + 1 => base_config.level(log::LevelFilter::Info), + 2 => base_config.level(log::LevelFilter::Debug), + _3_or_more => base_config.level(log::LevelFilter::Trace), + }; + + // Separate file config so we can include year, month and day in file logs + let file_config = fern::Dispatch::new() + .format(|out, message, record| { + out.finish(format_args!( + "{} {} [{}] {}", + chrono::Local::now().format("%Y-%m-%dT%H:%M:%S%.3f"), + record.target(), + record.level(), + message + )) + }) + .chain(fern::log_file("helix.log")?); + + base_config.chain(file_config).apply()?; + + Ok(()) +} + fn main() -> Result<(), Error> { let args = clap::app_from_crate!() .arg( @@ -20,8 +53,19 @@ fn main() -> Result<(), Error> { .multiple(true) .index(1), ) + .arg( + Arg::new("verbose") + .about("Increases logging verbosity each use for up to 3 times") + .short('v') + .takes_value(false) + .multiple_occurrences(true), + ) .get_matches(); + let verbosity: u64 = args.occurrences_of("verbose"); + + setup_logging(verbosity).expect("failed to initialize logging."); + for _ in 0..num_cpus::get() { std::thread::spawn(move || smol::block_on(EX.run(smol::future::pending::<()>()))); } From cc6bdf8f66889087223d9a8491479ceecc09a663 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Hrastnik?= Date: Fri, 23 Oct 2020 18:48:03 +0900 Subject: [PATCH 18/23] Text change generation, RPC call handling. --- helix-core/src/lib.rs | 2 +- helix-core/src/transaction.rs | 9 ++- helix-lsp/src/client.rs | 137 +++++++++++++++++++++++++++++++--- helix-lsp/src/lib.rs | 25 +++---- helix-lsp/src/transport.rs | 39 ++++++---- helix-term/src/application.rs | 87 ++++++++++++--------- helix-view/src/keymap.rs | 3 + 7 files changed, 225 insertions(+), 77 deletions(-) diff --git a/helix-core/src/lib.rs b/helix-core/src/lib.rs index 8458c36f7..ddf1439c2 100644 --- a/helix-core/src/lib.rs +++ b/helix-core/src/lib.rs @@ -27,4 +27,4 @@ pub use diagnostic::Diagnostic; pub use history::History; pub use state::State; -pub use transaction::{Assoc, Change, ChangeSet, Transaction}; +pub use transaction::{Assoc, Change, ChangeSet, Operation, Transaction}; diff --git a/helix-core/src/transaction.rs b/helix-core/src/transaction.rs index 9bd8c6152..f1cb2ca1d 100644 --- a/helix-core/src/transaction.rs +++ b/helix-core/src/transaction.rs @@ -5,8 +5,9 @@ use std::convert::TryFrom; /// (from, to, replacement) pub type Change = (usize, usize, Option); +// TODO: pub(crate) #[derive(Debug, Clone, PartialEq, Eq)] -pub(crate) enum Operation { +pub enum Operation { /// Move cursor by n characters. Retain(usize), /// Delete n characters. @@ -40,6 +41,12 @@ impl ChangeSet { } // TODO: from iter + // + + #[doc(hidden)] // used by lsp to convert to LSP changes + pub fn changes(&self) -> &[Operation] { + &self.changes + } #[must_use] fn len_after(&self) -> usize { diff --git a/helix-lsp/src/client.rs b/helix-lsp/src/client.rs index 56413768d..3c2c1ce02 100644 --- a/helix-lsp/src/client.rs +++ b/helix-lsp/src/client.rs @@ -1,11 +1,11 @@ use crate::{ transport::{Payload, Transport}, - Error, Notification, + Call, Error, }; type Result = core::result::Result; -use helix_core::{State, Transaction}; +use helix_core::{ChangeSet, Transaction}; use helix_view::Document; // use std::collections::HashMap; @@ -27,7 +27,7 @@ pub struct Client { stderr: BufReader, outgoing: Sender, - pub incoming: Receiver, + pub incoming: Receiver, pub request_counter: u64, @@ -87,6 +87,7 @@ impl Client { Ok(params) } + /// Execute a RPC request on the language server. pub async fn request( &mut self, params: R::Params, @@ -126,6 +127,7 @@ impl Client { Ok(response) } + /// Send a RPC notification to the language server. pub async fn notify( &mut self, params: R::Params, @@ -149,6 +151,35 @@ impl Client { Ok(()) } + /// Reply to a language server RPC call. + pub async fn reply( + &mut self, + id: jsonrpc::Id, + result: core::result::Result, + ) -> Result<()> { + use jsonrpc::{Failure, Output, Success, Version}; + + let output = match result { + Ok(result) => Output::Success(Success { + jsonrpc: Some(Version::V2), + id, + result, + }), + Err(error) => Output::Failure(Failure { + jsonrpc: Some(Version::V2), + id, + error, + }), + }; + + self.outgoing + .send(Payload::Response(output)) + .await + .map_err(|e| Error::Other(e.into()))?; + + Ok(()) + } + // ------------------------------------------------------------------------------------------- // General messages // ------------------------------------------------------------------------------------------- @@ -163,7 +194,9 @@ impl Client { // root_uri: Some(lsp_types::Url::parse("file://localhost/")?), root_uri: None, // set to project root in the future initialization_options: None, - capabilities: lsp::ClientCapabilities::default(), + capabilities: lsp::ClientCapabilities { + ..Default::default() + }, trace: None, workspace_folders: None, client_info: None, @@ -203,23 +236,107 @@ impl Client { .await } + fn to_changes(changeset: &ChangeSet) -> Vec { + let mut iter = changeset.changes().iter().peekable(); + let mut old_pos = 0; + + let mut changes = Vec::new(); + + use crate::util::pos_to_lsp_pos; + use helix_core::Operation::*; + + // TEMP + let rope = helix_core::Rope::from(""); + let old_text = rope.slice(..); + + while let Some(change) = iter.next() { + let len = match change { + Delete(i) | Retain(i) => *i, + Insert(_) => 0, + }; + let old_end = old_pos + len; + + match change { + Retain(_) => {} + Delete(_) => { + let start = pos_to_lsp_pos(&old_text, old_pos); + let end = pos_to_lsp_pos(&old_text, old_end); + + // a subsequent ins means a replace, consume it + if let Some(Insert(s)) = iter.peek() { + iter.next(); + + // replacement + changes.push(lsp::TextDocumentContentChangeEvent { + range: Some(lsp::Range::new(start, end)), + text: s.into(), + range_length: None, + }); + } else { + // deletion + changes.push(lsp::TextDocumentContentChangeEvent { + range: Some(lsp::Range::new(start, end)), + text: "".to_string(), + range_length: None, + }); + }; + } + Insert(s) => { + let start = pos_to_lsp_pos(&old_text, old_pos); + + // insert + changes.push(lsp::TextDocumentContentChangeEvent { + range: Some(lsp::Range::new(start, start)), + text: s.into(), + range_length: None, + }); + } + } + old_pos = old_end; + } + + changes + } + // TODO: trigger any time history.commit_revision happens pub async fn text_document_did_change( &mut self, doc: &Document, transaction: &Transaction, ) -> Result<()> { + // figure out what kind of sync the server supports + + let capabilities = self.capabilities.as_ref().unwrap(); // TODO: needs post init + + let sync_capabilities = match capabilities.text_document_sync { + Some(lsp::TextDocumentSyncCapability::Kind(kind)) => kind, + Some(lsp::TextDocumentSyncCapability::Options(lsp::TextDocumentSyncOptions { + change: Some(kind), + .. + })) => kind, + // None | SyncOptions { changes: None } + _ => return Ok(()), + }; + + let changes = match sync_capabilities { + lsp::TextDocumentSyncKind::Full => { + vec![lsp::TextDocumentContentChangeEvent { + // range = None -> whole document + range: None, //Some(Range) + range_length: None, // u64 apparently deprecated + text: "".to_string(), + }] // TODO: probably need old_state here too? + } + lsp::TextDocumentSyncKind::Incremental => Self::to_changes(transaction.changes()), + lsp::TextDocumentSyncKind::None => return Ok(()), + }; + self.notify::(lsp::DidChangeTextDocumentParams { text_document: lsp::VersionedTextDocumentIdentifier::new( lsp::Url::from_file_path(doc.path().unwrap()).unwrap(), doc.version, ), - content_changes: vec![lsp::TextDocumentContentChangeEvent { - // range = None -> whole document - range: None, //Some(Range) - range_length: None, // u64 apparently deprecated - text: "".to_string(), - }], // TODO: probably need old_state here too? + content_changes: changes, }) .await } diff --git a/helix-lsp/src/lib.rs b/helix-lsp/src/lib.rs index c37222f14..1ee8199f4 100644 --- a/helix-lsp/src/lib.rs +++ b/helix-lsp/src/lib.rs @@ -1,13 +1,12 @@ mod client; mod transport; -use jsonrpc_core as jsonrpc; -use lsp_types as lsp; +pub use jsonrpc_core as jsonrpc; +pub use lsp_types as lsp; pub use client::Client; pub use lsp::{Position, Url}; -use serde::{Deserialize, Serialize}; use thiserror::Error; #[derive(Error, Debug)] @@ -30,19 +29,13 @@ pub mod util { let line_start = doc.char_to_utf16_cu(line); doc.utf16_cu_to_char(pos.character as usize + line_start) } -} + pub fn pos_to_lsp_pos(doc: &helix_core::RopeSlice, pos: usize) -> lsp::Position { + let line = doc.char_to_line(pos); + let line_start = doc.char_to_utf16_cu(line); + let col = doc.char_to_utf16_cu(pos) - line_start; -/// A type representing all possible values sent from the server to the client. -#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] -#[serde(deny_unknown_fields)] -#[serde(untagged)] -enum Message { - /// A regular JSON-RPC request output (single response). - Output(jsonrpc::Output), - /// A notification. - Notification(jsonrpc::Notification), - /// A JSON-RPC request - Call(jsonrpc::Call), + lsp::Position::new(line as u64, col as u64) + } } #[derive(Debug, PartialEq, Clone)] @@ -67,3 +60,5 @@ impl Notification { } } } + +pub use jsonrpc::Call; diff --git a/helix-lsp/src/transport.rs b/helix-lsp/src/transport.rs index 4ab3d5ecf..4c349a13b 100644 --- a/helix-lsp/src/transport.rs +++ b/helix-lsp/src/transport.rs @@ -2,7 +2,7 @@ use std::collections::HashMap; use log::debug; -use crate::{Error, Message, Notification}; +use crate::{Error, Notification}; type Result = core::result::Result; @@ -24,10 +24,23 @@ pub(crate) enum Payload { value: jsonrpc::MethodCall, }, Notification(jsonrpc::Notification), + Response(jsonrpc::Output), +} + +use serde::{Deserialize, Serialize}; +/// A type representing all possible values sent from the server to the client. +#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +#[serde(untagged)] +enum Message { + /// A regular JSON-RPC request output (single response). + Output(jsonrpc::Output), + /// A JSON-RPC request or notification. + Call(jsonrpc::Call), } pub(crate) struct Transport { - incoming: Sender, // TODO Notification | Call + incoming: Sender, outgoing: Receiver, pending_requests: HashMap>>, @@ -42,7 +55,7 @@ impl Transport { ex: &Executor, reader: BufReader, writer: BufWriter, - ) -> (Receiver, Sender) { + ) -> (Receiver, Sender) { let (incoming, rx) = smol::channel::unbounded(); let (tx, outgoing) = smol::channel::unbounded(); @@ -112,6 +125,10 @@ impl Transport { let json = serde_json::to_string(&value)?; self.send(json).await } + Payload::Response(error) => { + let json = serde_json::to_string(&error)?; + self.send(json).await + } } } @@ -131,24 +148,18 @@ impl Transport { Ok(()) } - pub async fn recv_msg(&mut self, msg: Message) -> anyhow::Result<()> { + async fn recv_msg(&mut self, msg: Message) -> anyhow::Result<()> { match msg { Message::Output(output) => self.recv_response(output).await?, - Message::Notification(jsonrpc::Notification { method, params, .. }) => { - let notification = Notification::parse(&method, params); - - debug!("<- {} {:?}", method, notification); - self.incoming.send(notification).await?; - } Message::Call(call) => { - debug!("<- {:?}", call); - // dispatch + self.incoming.send(call).await?; + // let notification = Notification::parse(&method, params); } }; Ok(()) } - pub async fn recv_response(&mut self, output: jsonrpc::Output) -> anyhow::Result<()> { + async fn recv_response(&mut self, output: jsonrpc::Output) -> anyhow::Result<()> { match output { jsonrpc::Output::Success(jsonrpc::Success { id, result, .. }) => { debug!("<- {}", result); @@ -191,6 +202,8 @@ impl Transport { } let msg = msg.unwrap(); + debug!("<- {:?}", msg); + self.recv_msg(msg).await.unwrap(); } } diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs index b9594b7ea..802dd3992 100644 --- a/helix-term/src/application.rs +++ b/helix-term/src/application.rs @@ -433,8 +433,8 @@ impl<'a> Application<'a> { event = reader.next().fuse() => { self.handle_terminal_events(event).await } - notification = self.lsp.incoming.next().fuse() => { - self.handle_lsp_notification(notification).await + call = self.lsp.incoming.next().fuse() => { + self.handle_lsp_message(call).await } } } @@ -566,43 +566,56 @@ impl<'a> Application<'a> { }; } - pub async fn handle_lsp_notification(&mut self, notification: Option) { - use helix_lsp::Notification; - match notification { - Some(Notification::PublishDiagnostics(params)) => { - let path = Some(params.uri.to_file_path().unwrap()); - let view = self - .editor - .views - .iter_mut() - .find(|view| view.doc.path == path); - - if let Some(view) = view { - let doc = view.doc.text().slice(..); - let diagnostics = params - .diagnostics - .into_iter() - .map(|diagnostic| { - use helix_lsp::util::lsp_pos_to_pos; - let start = lsp_pos_to_pos(&doc, diagnostic.range.start); - let end = lsp_pos_to_pos(&doc, diagnostic.range.end); - - helix_core::Diagnostic { - range: (start, end), - line: diagnostic.range.start.line as usize, - message: diagnostic.message, - // severity - // code - // source - } - }) - .collect(); - - view.doc.diagnostics = diagnostics; - - self.render(); + pub async fn handle_lsp_message(&mut self, call: Option) { + use helix_lsp::{Call, Notification}; + match call { + Some(Call::Notification(helix_lsp::jsonrpc::Notification { + method, params, .. + })) => { + let notification = Notification::parse(&method, params); + match notification { + Notification::PublishDiagnostics(params) => { + let path = Some(params.uri.to_file_path().unwrap()); + let view = self + .editor + .views + .iter_mut() + .find(|view| view.doc.path == path); + + if let Some(view) = view { + let doc = view.doc.text().slice(..); + let diagnostics = params + .diagnostics + .into_iter() + .map(|diagnostic| { + use helix_lsp::util::lsp_pos_to_pos; + let start = lsp_pos_to_pos(&doc, diagnostic.range.start); + let end = lsp_pos_to_pos(&doc, diagnostic.range.end); + + helix_core::Diagnostic { + range: (start, end), + line: diagnostic.range.start.line as usize, + message: diagnostic.message, + // severity + // code + // source + } + }) + .collect(); + + view.doc.diagnostics = diagnostics; + + self.render(); + } + } + _ => unreachable!(), } } + Some(Call::MethodCall(call)) => { + // TODO: need to make Result + + unimplemented!("{:?}", call) + } _ => unreachable!(), } } diff --git a/helix-view/src/keymap.rs b/helix-view/src/keymap.rs index aaba34a67..c815911e8 100644 --- a/helix-view/src/keymap.rs +++ b/helix-view/src/keymap.rs @@ -82,6 +82,9 @@ use std::collections::HashMap; // = = align? // + = // } +// +// gd = goto definition +// gr = goto reference // } #[cfg(feature = "term")] From ae8a9e5bac2cb4683015604bb5a431781717c991 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Hrastnik?= Date: Thu, 29 Oct 2020 14:06:33 +0900 Subject: [PATCH 19/23] lsp: Make base request methods take &self instead of &mut self. --- Cargo.lock | 84 +++++++++++++++++++---------------- helix-lsp/Cargo.toml | 2 +- helix-lsp/src/client.rs | 28 +++++------- helix-term/src/application.rs | 23 +++++----- helix-view/src/commands.rs | 2 + 5 files changed, 72 insertions(+), 67 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index bc3da508f..28fc503cb 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -29,9 +29,9 @@ checksum = "a4c527152e37cf757a3f78aae5a06fbeefdb07ccc535c980a3208ee3060dd544" [[package]] name = "arrayvec" -version = "0.5.1" +version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cff77d8686867eceff3105329d4698d96c2391c176d5d03adc90c7389162b5b8" +checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b" [[package]] name = "async-channel" @@ -118,7 +118,7 @@ checksum = "4c8cea09c1fb10a317d1b5af8024eeba256d6554763e85ecd90ff8df31c7bbda" dependencies = [ "async-io", "blocking", - "cfg-if", + "cfg-if 0.1.10", "event-listener", "futures-lite", "once_cell", @@ -208,6 +208,12 @@ version = "0.1.10" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822" +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + [[package]] name = "chrono" version = "0.4.19" @@ -267,15 +273,15 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c3c7c73a2d1e9fc0886a08b93e98eb643461230d5f1925e4036204d5f2e261a8" dependencies = [ "autocfg", - "cfg-if", + "cfg-if 0.1.10", "lazy_static", ] [[package]] name = "crossterm" -version = "0.18.0" +version = "0.18.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c2fcdc3c9cf8ee446222e8ee8691a6d21b563b8fe1a64b1873080db7b5b23cf0" +checksum = "cef9149b29071d44c9fb98fd9c27fcf74405bbdb761889ad6a03f36be93b0b15" dependencies = [ "bitflags", "crossterm_winapi", @@ -290,9 +296,9 @@ dependencies = [ [[package]] name = "crossterm_winapi" -version = "0.6.1" +version = "0.6.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "057b7146d02fb50175fd7dbe5158f6097f33d02831f43b4ee8ae4ddf67b68f5c" +checksum = "c2265c3f8e080075d9b6417aa72293fc71662f34b4af2612d8d1b074d29510db" dependencies = [ "winapi", ] @@ -303,7 +309,7 @@ version = "2.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "13aea89a5c93364a98e9b37b2fa237effbb694d5cfe01c5b70941f7eb087d5e3" dependencies = [ - "cfg-if", + "cfg-if 0.1.10", "dirs-sys", ] @@ -360,15 +366,15 @@ checksum = "4c7e4c2612746b0df8fed4ce0c69156021b704c9aefa360311c04e6e9e002eed" [[package]] name = "futures-core" -version = "0.3.6" +version = "0.3.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d674eaa0056896d5ada519900dbf97ead2e46a7b6621e8160d79e2f2e1e2784b" +checksum = "18eaa56102984bed2c88ea39026cff3ce3b4c7f508ca970cedf2450ea10d4e46" [[package]] name = "futures-io" -version = "0.3.6" +version = "0.3.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5fc94b64bb39543b4e432f1790b6bf18e3ee3b74653c5449f63310e9a74b123c" +checksum = "6e1798854a4727ff944a7b12aa999f58ce7aa81db80d2dfaaf2ba06f065ddd2b" [[package]] name = "futures-lite" @@ -387,9 +393,9 @@ dependencies = [ [[package]] name = "futures-macro" -version = "0.3.6" +version = "0.3.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f57ed14da4603b2554682e9f2ff3c65d7567b53188db96cb71538217fc64581b" +checksum = "e36fccf3fc58563b4a14d265027c627c3b665d7fed489427e88e7cc929559efe" dependencies = [ "proc-macro-hack", "proc-macro2", @@ -399,18 +405,18 @@ dependencies = [ [[package]] name = "futures-task" -version = "0.3.6" +version = "0.3.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4dd26820a9f3637f1302da8bceba3ff33adbe53464b54ca24d4e2d4f1db30f94" +checksum = "96d502af37186c4fef99453df03e374683f8a1eec9dcc1e66b3b82dc8278ce3c" dependencies = [ "once_cell", ] [[package]] name = "futures-util" -version = "0.3.6" +version = "0.3.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a894a0acddba51a2d49a6f4263b1e64b8c579ece8af50fa86503d52cd1eea34" +checksum = "abcb44342f62e6f3e8ac427b8aa815f724fd705dfad060b18ac7866c15bb8e34" dependencies = [ "futures-core", "futures-macro", @@ -428,7 +434,7 @@ version = "0.1.15" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fc587bc0ec293155d5bfa6b9891ec18a1e330c234f896ea47fbada4cadbe47e6" dependencies = [ - "cfg-if", + "cfg-if 0.1.10", "libc", "wasi 0.9.0+wasi-snapshot-preview1", ] @@ -553,11 +559,11 @@ dependencies = [ [[package]] name = "instant" -version = "0.1.7" +version = "0.1.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "63312a18f7ea8760cdd0a7c5aac1a619752a246b833545e3e36d1f81f7cd9e66" +checksum = "cb1fc4429a33e1f80d41dc9fea4d108a88bec1de8053878898ae448a0b52f613" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", ] [[package]] @@ -596,9 +602,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" [[package]] name = "libc" -version = "0.2.79" +version = "0.2.80" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2448f6066e80e3bfc792e9c98bf705b4b0fc6e8ef5b43e5889aff0eaa9c58743" +checksum = "4d58d1b70b004888f764dfbf6a26a3b0342a1632d33968e4a179d8011c760614" [[package]] name = "lock_api" @@ -615,14 +621,14 @@ version = "0.4.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4fabed175da42fed1fa0746b0ea71f412aa9d35e76e95e59b192c64b9dc2bf8b" dependencies = [ - "cfg-if", + "cfg-if 0.1.10", ] [[package]] name = "lsp-types" -version = "0.82.0" +version = "0.83.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "db895abb8527cf59e3de893ab2acf52cf904faeb65e60ea6f373e11fe86464e8" +checksum = "25e0bd4b95038f2c23bda332ba0ca684e8dda765db1f9bdb63dc4c3e01f3b456" dependencies = [ "base64", "bitflags", @@ -691,9 +697,9 @@ checksum = "e4a24736216ec316047a1fc4252e27dabb04218aa4a3f37c6e7ddbf1f9782b54" [[package]] name = "ntapi" -version = "0.3.4" +version = "0.3.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a31937dea023539c72ddae0e3571deadc1414b300483fa7aaec176168cfa9d2" +checksum = "3f6bb902e437b6d86e03cce10a7e2af662292c5dfef23b65899ea3ac9354ad44" dependencies = [ "winapi", ] @@ -762,7 +768,7 @@ version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c361aa727dd08437f2f1447be8b59a33b0edd15e0fcee698f935613d9efbca9b" dependencies = [ - "cfg-if", + "cfg-if 0.1.10", "cloudabi", "instant", "libc", @@ -785,18 +791,18 @@ checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e" [[package]] name = "pin-project" -version = "0.4.27" +version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2ffbc8e94b38ea3d2d8ba92aea2983b503cd75d0888d75b86bb37970b5698e15" +checksum = "ee41d838744f60d959d7074e3afb6b35c7456d0f61cad38a24e35e6553f73841" dependencies = [ "pin-project-internal", ] [[package]] name = "pin-project-internal" -version = "0.4.27" +version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "65ad2ae56b6abe3a1ee25f15ee605bacadb9a764edaba9c2bf4103800d4a1895" +checksum = "81a4ffa594b66bff340084d4081df649a7dc049ac8d7fc458d8e628bfbbb2f86" dependencies = [ "proc-macro2", "quote", @@ -821,7 +827,7 @@ version = "2.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a2a7bc6b2a29e632e45451c941832803a18cce6781db04de8a04696cdca8bde4" dependencies = [ - "cfg-if", + "cfg-if 0.1.10", "libc", "log", "wepoll-sys", @@ -1034,7 +1040,7 @@ version = "0.3.15" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b1fa70dc5c8104ec096f4fe7ede7a221d35ae13dcd19ba1ad9a81d2cab9a1c44" dependencies = [ - "cfg-if", + "cfg-if 0.1.10", "libc", "redox_syscall", "winapi", @@ -1042,9 +1048,9 @@ dependencies = [ [[package]] name = "syn" -version = "1.0.46" +version = "1.0.48" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ad5de3220ea04da322618ded2c42233d02baca219d6f160a3e9c87cda16c942" +checksum = "cc371affeffc477f42a221a1e4297aedcea33d47d19b61455588bd9d8f6b19ac" dependencies = [ "proc-macro2", "quote", diff --git a/helix-lsp/Cargo.toml b/helix-lsp/Cargo.toml index ffd909a4d..0c5d8b918 100644 --- a/helix-lsp/Cargo.toml +++ b/helix-lsp/Cargo.toml @@ -10,7 +10,7 @@ edition = "2018" helix-core = { path = "../helix-core" } helix-view = { path = "../helix-view" } -lsp-types = { version = "0.82", features = ["proposed"] } +lsp-types = { version = "0.83", features = ["proposed"] } smol = "1.2" url = "2" pathdiff = "0.2" diff --git a/helix-lsp/src/client.rs b/helix-lsp/src/client.rs index 3c2c1ce02..1583bfb84 100644 --- a/helix-lsp/src/client.rs +++ b/helix-lsp/src/client.rs @@ -9,6 +9,7 @@ use helix_core::{ChangeSet, Transaction}; use helix_view::Document; // use std::collections::HashMap; +use std::sync::atomic::{AtomicU64, Ordering}; use jsonrpc_core as jsonrpc; use lsp_types as lsp; @@ -29,7 +30,7 @@ pub struct Client { outgoing: Sender, pub incoming: Receiver, - pub request_counter: u64, + pub request_counter: AtomicU64, capabilities: Option, // TODO: handle PublishDiagnostics Version @@ -61,17 +62,16 @@ impl Client { outgoing, incoming, - request_counter: 0, + request_counter: AtomicU64::new(0), capabilities: None, // diagnostics: HashMap::new(), } } - fn next_request_id(&mut self) -> jsonrpc::Id { - let id = jsonrpc::Id::Num(self.request_counter); - self.request_counter += 1; - id + fn next_request_id(&self) -> jsonrpc::Id { + let id = self.request_counter.fetch_add(1, Ordering::Relaxed); + jsonrpc::Id::Num(id) } fn to_params(value: Value) -> Result { @@ -88,10 +88,7 @@ impl Client { } /// Execute a RPC request on the language server. - pub async fn request( - &mut self, - params: R::Params, - ) -> Result + pub async fn request(&self, params: R::Params) -> Result where R::Params: serde::Serialize, R::Result: core::fmt::Debug, // TODO: temporary @@ -128,10 +125,7 @@ impl Client { } /// Send a RPC notification to the language server. - pub async fn notify( - &mut self, - params: R::Params, - ) -> Result<()> + pub async fn notify(&self, params: R::Params) -> Result<()> where R::Params: serde::Serialize, { @@ -153,7 +147,7 @@ impl Client { /// Reply to a language server RPC call. pub async fn reply( - &mut self, + &self, id: jsonrpc::Id, result: core::result::Result, ) -> Result<()> { @@ -212,11 +206,11 @@ impl Client { Ok(()) } - pub async fn shutdown(&mut self) -> Result<()> { + pub async fn shutdown(&self) -> Result<()> { self.request::(()).await } - pub async fn exit(&mut self) -> Result<()> { + pub async fn exit(&self) -> Result<()> { self.notify::(()).await } diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs index 802dd3992..a4a3cf096 100644 --- a/helix-term/src/application.rs +++ b/helix-term/src/application.rs @@ -8,6 +8,8 @@ use helix_view::{ Document, Editor, Theme, View, }; +use log::{debug, info}; + use std::{ borrow::Cow, io::{self, stdout, Stdout, Write}, @@ -46,7 +48,7 @@ pub struct Application<'a> { keymap: Keymaps, executor: &'a smol::Executor<'a>, - lsp: helix_lsp::Client, + language_server: helix_lsp::Client, } struct Renderer { @@ -370,7 +372,7 @@ impl<'a> Application<'a> { editor.open(file, terminal.size)?; } - let lsp = helix_lsp::Client::start(&executor, "rust-analyzer", &[]); + let language_server = helix_lsp::Client::start(&executor, "rust-analyzer", &[]); let mut app = Self { editor, @@ -381,7 +383,7 @@ impl<'a> Application<'a> { // keymap: keymap::default(), executor, - lsp, + language_server, }; Ok(app) @@ -415,11 +417,11 @@ impl<'a> Application<'a> { let mut reader = EventStream::new(); // initialize lsp - let res = self.lsp.initialize().await; - let res = self - .lsp + self.language_server.initialize().await.unwrap(); + self.language_server .text_document_did_open(&self.editor.view().unwrap().doc) - .await; + .await + .unwrap(); self.render(); @@ -433,8 +435,8 @@ impl<'a> Application<'a> { event = reader.next().fuse() => { self.handle_terminal_events(event).await } - call = self.lsp.incoming.next().fuse() => { - self.handle_lsp_message(call).await + call = self.language_server.incoming.next().fuse() => { + self.handle_language_server_message(call).await } } } @@ -566,7 +568,7 @@ impl<'a> Application<'a> { }; } - pub async fn handle_lsp_message(&mut self, call: Option) { + pub async fn handle_language_server_message(&mut self, call: Option) { use helix_lsp::{Call, Notification}; match call { Some(Call::Notification(helix_lsp::jsonrpc::Notification { @@ -605,6 +607,7 @@ impl<'a> Application<'a> { view.doc.diagnostics = diagnostics; + // TODO: we want to process all the events in queue, then render. publishDiagnostic tends to send a whole bunch of events self.render(); } } diff --git a/helix-view/src/commands.rs b/helix-view/src/commands.rs index 52e09dd67..f2e62044a 100644 --- a/helix-view/src/commands.rs +++ b/helix-view/src/commands.rs @@ -404,6 +404,8 @@ fn append_changes_to_history(view: &mut View) { let old_state = std::mem::replace(&mut view.doc.old_state, view.doc.state.clone()); // TODO: take transaction by value? view.doc.history.commit_revision(&transaction, &old_state); + + // TODO: notify LSP of changes } pub fn normal_mode(view: &mut View, _count: usize) { From 8f0bcfe286d97dfff67bd924e11ca2b6ae1a63dc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Hrastnik?= Date: Fri, 30 Oct 2020 14:09:59 +0900 Subject: [PATCH 20/23] Introduce a command context that carries the executor and other fields. --- helix-term/src/application.rs | 29 ++- helix-view/src/commands.rs | 454 ++++++++++++++++++---------------- 2 files changed, 264 insertions(+), 219 deletions(-) diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs index a4a3cf096..cacfde56a 100644 --- a/helix-term/src/application.rs +++ b/helix-term/src/application.rs @@ -476,13 +476,24 @@ impl<'a> Application<'a> { match view.doc.mode() { Mode::Insert => { if let Some(command) = self.keymap[&Mode::Insert].get(&keys) { - command(view, 1); + let mut cx = helix_view::commands::Context { + view, + executor: self.executor, + count: 1, + }; + + command(&mut cx); } else if let KeyEvent { code: KeyCode::Char(c), .. } = event { - commands::insert::insert_char(view, c); + let mut cx = helix_view::commands::Context { + view, + executor: self.executor, + count: 1, + }; + commands::insert::insert_char(&mut cx, c); } view.ensure_cursor_in_view(); } @@ -544,7 +555,12 @@ impl<'a> Application<'a> { // HAXX: special casing for command mode } else if let Some(command) = self.keymap[&Mode::Normal].get(&keys) { - command(view, 1); + let mut cx = helix_view::commands::Context { + view, + executor: self.executor, + count: 1, + }; + command(&mut cx); // TODO: simplistic ensure cursor in view for now view.ensure_cursor_in_view(); @@ -552,7 +568,12 @@ impl<'a> Application<'a> { } mode => { if let Some(command) = self.keymap[&mode].get(&keys) { - command(view, 1); + let mut cx = helix_view::commands::Context { + view, + executor: self.executor, + count: 1, + }; + command(&mut cx); // TODO: simplistic ensure cursor in view for now view.ensure_cursor_in_view(); diff --git a/helix-view/src/commands.rs b/helix-view/src/commands.rs index f2e62044a..26c7a1901 100644 --- a/helix-view/src/commands.rs +++ b/helix-view/src/commands.rs @@ -14,44 +14,54 @@ use crate::{ view::{View, PADDING}, }; +pub struct Context<'a, 'b> { + pub count: usize, + pub view: &'a mut View, + pub executor: &'a smol::Executor<'b>, +} + /// A command is a function that takes the current state and a count, and does a side-effect on the /// state (usually by creating and applying a transaction). -pub type Command = fn(view: &mut View, count: usize); +pub type Command = fn(cx: &mut Context); -pub fn move_char_left(view: &mut View, count: usize) { +pub fn move_char_left(cx: &mut Context) { let selection = - view.doc + cx.view + .doc .state - .move_selection(Direction::Backward, Granularity::Character, count); - view.doc.set_selection(selection); + .move_selection(Direction::Backward, Granularity::Character, cx.count); + cx.view.doc.set_selection(selection); } -pub fn move_char_right(view: &mut View, count: usize) { +pub fn move_char_right(cx: &mut Context) { let selection = - view.doc + cx.view + .doc .state - .move_selection(Direction::Forward, Granularity::Character, count); - view.doc.set_selection(selection); + .move_selection(Direction::Forward, Granularity::Character, cx.count); + cx.view.doc.set_selection(selection); } -pub fn move_line_up(view: &mut View, count: usize) { - let selection = view - .doc - .state - .move_selection(Direction::Backward, Granularity::Line, count); - view.doc.set_selection(selection); +pub fn move_line_up(cx: &mut Context) { + let selection = + cx.view + .doc + .state + .move_selection(Direction::Backward, Granularity::Line, cx.count); + cx.view.doc.set_selection(selection); } -pub fn move_line_down(view: &mut View, count: usize) { - let selection = view - .doc - .state - .move_selection(Direction::Forward, Granularity::Line, count); - view.doc.set_selection(selection); +pub fn move_line_down(cx: &mut Context) { + let selection = + cx.view + .doc + .state + .move_selection(Direction::Forward, Granularity::Line, cx.count); + cx.view.doc.set_selection(selection); } -pub fn move_line_end(view: &mut View, _count: usize) { - let lines = selection_lines(&view.doc.state); +pub fn move_line_end(cx: &mut Context) { + let lines = selection_lines(&cx.view.doc.state); let positions = lines .into_iter() @@ -60,78 +70,78 @@ pub fn move_line_end(view: &mut View, _count: usize) { // Line end is pos at the start of next line - 1 // subtract another 1 because the line ends with \n - view.doc.text().line_to_char(index + 1).saturating_sub(2) + cx.view.doc.text().line_to_char(index + 1).saturating_sub(2) }) .map(|pos| Range::new(pos, pos)); let selection = Selection::new(positions.collect(), 0); - view.doc.set_selection(selection); + cx.view.doc.set_selection(selection); } -pub fn move_line_start(view: &mut View, _count: usize) { - let lines = selection_lines(&view.doc.state); +pub fn move_line_start(cx: &mut Context) { + let lines = selection_lines(&cx.view.doc.state); let positions = lines .into_iter() .map(|index| { // adjust all positions to the start of the line. - view.doc.text().line_to_char(index) + cx.view.doc.text().line_to_char(index) }) .map(|pos| Range::new(pos, pos)); let selection = Selection::new(positions.collect(), 0); - view.doc.set_selection(selection); + cx.view.doc.set_selection(selection); } -pub fn move_next_word_start(view: &mut View, count: usize) { - let pos = view.doc.state.move_pos( - view.doc.selection().cursor(), +pub fn move_next_word_start(cx: &mut Context) { + let pos = cx.view.doc.state.move_pos( + cx.view.doc.selection().cursor(), Direction::Forward, Granularity::Word, - count, + cx.count, ); - view.doc.set_selection(Selection::point(pos)); + cx.view.doc.set_selection(Selection::point(pos)); } -pub fn move_prev_word_start(view: &mut View, count: usize) { - let pos = view.doc.state.move_pos( - view.doc.selection().cursor(), +pub fn move_prev_word_start(cx: &mut Context) { + let pos = cx.view.doc.state.move_pos( + cx.view.doc.selection().cursor(), Direction::Backward, Granularity::Word, - count, + cx.count, ); - view.doc.set_selection(Selection::point(pos)); + cx.view.doc.set_selection(Selection::point(pos)); } -pub fn move_next_word_end(view: &mut View, count: usize) { +pub fn move_next_word_end(cx: &mut Context) { let pos = State::move_next_word_end( - &view.doc.text().slice(..), - view.doc.selection().cursor(), - count, + &cx.view.doc.text().slice(..), + cx.view.doc.selection().cursor(), + cx.count, ); - view.doc.set_selection(Selection::point(pos)); + cx.view.doc.set_selection(Selection::point(pos)); } -pub fn move_file_start(view: &mut View, _count: usize) { - view.doc.set_selection(Selection::point(0)); +pub fn move_file_start(cx: &mut Context) { + cx.view.doc.set_selection(Selection::point(0)); - view.doc.mode = Mode::Normal; + cx.view.doc.mode = Mode::Normal; } -pub fn move_file_end(view: &mut View, _count: usize) { - let text = &view.doc.text(); +pub fn move_file_end(cx: &mut Context) { + let text = &cx.view.doc.text(); let last_line = text.line_to_char(text.len_lines().saturating_sub(2)); - view.doc.set_selection(Selection::point(last_line)); + cx.view.doc.set_selection(Selection::point(last_line)); - view.doc.mode = Mode::Normal; + cx.view.doc.mode = Mode::Normal; } -pub fn check_cursor_in_view(view: &mut View) -> bool { +pub fn check_cursor_in_view(view: &View) -> bool { let cursor = view.doc.selection().cursor(); let line = view.doc.text().char_to_line(cursor); let document_end = view.first_line + view.size.1.saturating_sub(1) as usize; @@ -142,172 +152,182 @@ pub fn check_cursor_in_view(view: &mut View) -> bool { true } -pub fn page_up(view: &mut View, _count: usize) { - if view.first_line < PADDING { +pub fn page_up(cx: &mut Context) { + if cx.view.first_line < PADDING { return; } - view.first_line = view.first_line.saturating_sub(view.size.1 as usize); + cx.view.first_line = cx.view.first_line.saturating_sub(cx.view.size.1 as usize); - if !check_cursor_in_view(view) { - let text = view.doc.text(); - let pos = text.line_to_char(view.last_line().saturating_sub(PADDING)); - view.doc.set_selection(Selection::point(pos)); + if !check_cursor_in_view(cx.view) { + let text = cx.view.doc.text(); + let pos = text.line_to_char(cx.view.last_line().saturating_sub(PADDING)); + cx.view.doc.set_selection(Selection::point(pos)); } } -pub fn page_down(view: &mut View, _count: usize) { - view.first_line += view.size.1 as usize + PADDING; +pub fn page_down(cx: &mut Context) { + cx.view.first_line += cx.view.size.1 as usize + PADDING; - if view.first_line < view.doc.text().len_lines() { - let text = view.doc.text(); - let pos = text.line_to_char(view.first_line as usize); - view.doc.set_selection(Selection::point(pos)); + if cx.view.first_line < cx.view.doc.text().len_lines() { + let text = cx.view.doc.text(); + let pos = text.line_to_char(cx.view.first_line as usize); + cx.view.doc.set_selection(Selection::point(pos)); } } -pub fn half_page_up(view: &mut View, _count: usize) { - if view.first_line < PADDING { +pub fn half_page_up(cx: &mut Context) { + if cx.view.first_line < PADDING { return; } - view.first_line = view.first_line.saturating_sub(view.size.1 as usize / 2); + cx.view.first_line = cx + .view + .first_line + .saturating_sub(cx.view.size.1 as usize / 2); - if !check_cursor_in_view(view) { - let text = &view.doc.text(); - let pos = text.line_to_char(view.last_line() - PADDING); - view.doc.set_selection(Selection::point(pos)); + if !check_cursor_in_view(cx.view) { + let text = &cx.view.doc.text(); + let pos = text.line_to_char(cx.view.last_line() - PADDING); + cx.view.doc.set_selection(Selection::point(pos)); } } -pub fn half_page_down(view: &mut View, _count: usize) { - let lines = view.doc.text().len_lines(); - if view.first_line < lines.saturating_sub(view.size.1 as usize) { - view.first_line += view.size.1 as usize / 2; +pub fn half_page_down(cx: &mut Context) { + let lines = cx.view.doc.text().len_lines(); + if cx.view.first_line < lines.saturating_sub(cx.view.size.1 as usize) { + cx.view.first_line += cx.view.size.1 as usize / 2; } - if !check_cursor_in_view(view) { - let text = view.doc.text(); - let pos = text.line_to_char(view.first_line as usize); - view.doc.set_selection(Selection::point(pos)); + if !check_cursor_in_view(cx.view) { + let text = cx.view.doc.text(); + let pos = text.line_to_char(cx.view.first_line as usize); + cx.view.doc.set_selection(Selection::point(pos)); } } // avoid select by default by having a visual mode switch that makes movements into selects -pub fn extend_char_left(view: &mut View, count: usize) { +pub fn extend_char_left(cx: &mut Context) { let selection = - view.doc + cx.view + .doc .state - .extend_selection(Direction::Backward, Granularity::Character, count); - view.doc.set_selection(selection); + .extend_selection(Direction::Backward, Granularity::Character, cx.count); + cx.view.doc.set_selection(selection); } -pub fn extend_char_right(view: &mut View, count: usize) { +pub fn extend_char_right(cx: &mut Context) { let selection = - view.doc + cx.view + .doc .state - .extend_selection(Direction::Forward, Granularity::Character, count); - view.doc.set_selection(selection); + .extend_selection(Direction::Forward, Granularity::Character, cx.count); + cx.view.doc.set_selection(selection); } -pub fn extend_line_up(view: &mut View, count: usize) { - let selection = view - .doc - .state - .extend_selection(Direction::Backward, Granularity::Line, count); - view.doc.set_selection(selection); +pub fn extend_line_up(cx: &mut Context) { + let selection = + cx.view + .doc + .state + .extend_selection(Direction::Backward, Granularity::Line, cx.count); + cx.view.doc.set_selection(selection); } -pub fn extend_line_down(view: &mut View, count: usize) { - let selection = view - .doc - .state - .extend_selection(Direction::Forward, Granularity::Line, count); - view.doc.set_selection(selection); +pub fn extend_line_down(cx: &mut Context) { + let selection = + cx.view + .doc + .state + .extend_selection(Direction::Forward, Granularity::Line, cx.count); + cx.view.doc.set_selection(selection); } -pub fn split_selection_on_newline(view: &mut View, _count: usize) { - let text = &view.doc.text().slice(..); +pub fn split_selection_on_newline(cx: &mut Context) { + let text = &cx.view.doc.text().slice(..); // only compile the regex once #[allow(clippy::trivial_regex)] static REGEX: Lazy = Lazy::new(|| Regex::new(r"\n").unwrap()); - let selection = selection::split_on_matches(text, view.doc.selection(), ®EX); - view.doc.set_selection(selection); + let selection = selection::split_on_matches(text, cx.view.doc.selection(), ®EX); + cx.view.doc.set_selection(selection); } -pub fn select_line(view: &mut View, _count: usize) { +pub fn select_line(cx: &mut Context) { // TODO: count - let pos = view.doc.selection().primary(); - let text = view.doc.text(); + let pos = cx.view.doc.selection().primary(); + let text = cx.view.doc.text(); let line = text.char_to_line(pos.head); let start = text.line_to_char(line); let end = text.line_to_char(line + 1).saturating_sub(1); - view.doc.set_selection(Selection::single(start, end)); + cx.view.doc.set_selection(Selection::single(start, end)); } -pub fn delete_selection(view: &mut View, _count: usize) { - let transaction = Transaction::change_by_selection(&view.doc.state, |range| { +pub fn delete_selection(cx: &mut Context) { + let transaction = Transaction::change_by_selection(&cx.view.doc.state, |range| { (range.from(), range.to() + 1, None) }); - view.doc.apply(&transaction); + cx.view.doc.apply(&transaction); - append_changes_to_history(view); + append_changes_to_history(cx); } -pub fn change_selection(view: &mut View, count: usize) { - delete_selection(view, count); - insert_mode(view, count); +pub fn change_selection(cx: &mut Context) { + delete_selection(cx); + insert_mode(cx); } -pub fn collapse_selection(view: &mut View, _count: usize) { - let selection = view +pub fn collapse_selection(cx: &mut Context) { + let selection = cx + .view .doc .selection() .transform(|range| Range::new(range.head, range.head)); - view.doc.set_selection(selection); + cx.view.doc.set_selection(selection); } -pub fn flip_selections(view: &mut View, _count: usize) { - let selection = view +pub fn flip_selections(cx: &mut Context) { + let selection = cx + .view .doc .selection() .transform(|range| Range::new(range.head, range.anchor)); - view.doc.set_selection(selection); + cx.view.doc.set_selection(selection); } -fn enter_insert_mode(view: &mut View) { - view.doc.mode = Mode::Insert; +fn enter_insert_mode(cx: &mut Context) { + cx.view.doc.mode = Mode::Insert; - append_changes_to_history(view); + append_changes_to_history(cx); } // inserts at the start of each selection -pub fn insert_mode(view: &mut View, _count: usize) { - enter_insert_mode(view); +pub fn insert_mode(cx: &mut Context) { + enter_insert_mode(cx); - let selection = view + let selection = cx + .view .doc .selection() .transform(|range| Range::new(range.to(), range.from())); - view.doc.set_selection(selection); + cx.view.doc.set_selection(selection); } // inserts at the end of each selection -pub fn append_mode(view: &mut View, _count: usize) { - enter_insert_mode(view); - view.doc.restore_cursor = true; +pub fn append_mode(cx: &mut Context) { + enter_insert_mode(cx); + cx.view.doc.restore_cursor = true; // TODO: as transaction - let text = &view.doc.text().slice(..); - let selection = view.doc.selection().transform(|range| { + let text = &cx.view.doc.text().slice(..); + let selection = cx.view.doc.selection().transform(|range| { // TODO: to() + next char Range::new( range.from(), graphemes::next_grapheme_boundary(text, range.to()), ) }); - view.doc.set_selection(selection); + cx.view.doc.set_selection(selection); } // TODO: I, A, o and O can share a lot of the primitives. @@ -332,30 +352,30 @@ fn selection_lines(state: &State) -> Vec { } // I inserts at the start of each line with a selection -pub fn prepend_to_line(view: &mut View, count: usize) { - enter_insert_mode(view); +pub fn prepend_to_line(cx: &mut Context) { + enter_insert_mode(cx); - move_line_start(view, count); + move_line_start(cx); } // A inserts at the end of each line with a selection -pub fn append_to_line(view: &mut View, count: usize) { - enter_insert_mode(view); +pub fn append_to_line(cx: &mut Context) { + enter_insert_mode(cx); - move_line_end(view, count); + move_line_end(cx); } // o inserts a new line after each line with a selection -pub fn open_below(view: &mut View, _count: usize) { - enter_insert_mode(view); +pub fn open_below(cx: &mut Context) { + enter_insert_mode(cx); - let lines = selection_lines(&view.doc.state); + let lines = selection_lines(&cx.view.doc.state); let positions: Vec<_> = lines .into_iter() .map(|index| { // adjust all positions to the end of the line/start of the next one. - view.doc.text().line_to_char(index + 1) + cx.view.doc.text().line_to_char(index + 1) }) .collect(); @@ -376,82 +396,85 @@ pub fn open_below(view: &mut View, _count: usize) { 0, ); - let transaction = Transaction::change(&view.doc.state, changes).with_selection(selection); + let transaction = Transaction::change(&cx.view.doc.state, changes).with_selection(selection); - view.doc.apply(&transaction); + cx.view.doc.apply(&transaction); } // O inserts a new line before each line with a selection -fn append_changes_to_history(view: &mut View) { - if view.doc.changes.is_empty() { +fn append_changes_to_history(cx: &mut Context) { + if cx.view.doc.changes.is_empty() { return; } - let new_changeset = ChangeSet::new(view.doc.text()); - let changes = std::mem::replace(&mut view.doc.changes, new_changeset); + let new_changeset = ChangeSet::new(cx.view.doc.text()); + let changes = std::mem::replace(&mut cx.view.doc.changes, new_changeset); // Instead of doing this messy merge we could always commit, and based on transaction // annotations either add a new layer or compose into the previous one. - let transaction = Transaction::from(changes).with_selection(view.doc.selection().clone()); + let transaction = Transaction::from(changes).with_selection(cx.view.doc.selection().clone()); // increment document version // TODO: needs to happen on undo/redo too - view.doc.version += 1; + cx.view.doc.version += 1; // TODO: trigger lsp/documentDidChange with changes // HAXX: we need to reconstruct the state as it was before the changes.. - let old_state = std::mem::replace(&mut view.doc.old_state, view.doc.state.clone()); + let old_state = std::mem::replace(&mut cx.view.doc.old_state, cx.view.doc.state.clone()); // TODO: take transaction by value? - view.doc.history.commit_revision(&transaction, &old_state); + cx.view + .doc + .history + .commit_revision(&transaction, &old_state); // TODO: notify LSP of changes } -pub fn normal_mode(view: &mut View, _count: usize) { - view.doc.mode = Mode::Normal; +pub fn normal_mode(cx: &mut Context) { + cx.view.doc.mode = Mode::Normal; - append_changes_to_history(view); + append_changes_to_history(cx); // if leaving append mode, move cursor back by 1 - if view.doc.restore_cursor { - let text = &view.doc.text().slice(..); - let selection = view.doc.selection().transform(|range| { + if cx.view.doc.restore_cursor { + let text = &cx.view.doc.text().slice(..); + let selection = cx.view.doc.selection().transform(|range| { Range::new( range.from(), graphemes::prev_grapheme_boundary(text, range.to()), ) }); - view.doc.set_selection(selection); + cx.view.doc.set_selection(selection); - view.doc.restore_cursor = false; + cx.view.doc.restore_cursor = false; } } -pub fn goto_mode(view: &mut View, _count: usize) { - view.doc.mode = Mode::Goto; +pub fn goto_mode(cx: &mut Context) { + cx.view.doc.mode = Mode::Goto; } // NOTE: Transactions in this module get appended to history when we switch back to normal mode. pub mod insert { use super::*; // TODO: insert means add text just before cursor, on exit we should be on the last letter. - pub fn insert_char(view: &mut View, c: char) { + pub fn insert_char(cx: &mut Context, c: char) { let c = Tendril::from_char(c); - let transaction = Transaction::insert(&view.doc.state, c); + let transaction = Transaction::insert(&cx.view.doc.state, c); - view.doc.apply(&transaction); + cx.view.doc.apply(&transaction); } - pub fn insert_tab(view: &mut View, _count: usize) { - insert_char(view, '\t'); + pub fn insert_tab(cx: &mut Context) { + insert_char(cx, '\t'); } - pub fn insert_newline(view: &mut View, _count: usize) { - let transaction = Transaction::change_by_selection(&view.doc.state, |range| { + pub fn insert_newline(cx: &mut Context) { + let transaction = Transaction::change_by_selection(&cx.view.doc.state, |range| { let indent_level = helix_core::indent::suggested_indent_for_pos( - view.doc.syntax.as_ref(), - &view.doc.state, + cx.view.doc.syntax.as_ref(), + &cx.view.doc.state, range.head, ); let indent = " ".repeat(TAB_WIDTH).repeat(indent_level); @@ -460,32 +483,32 @@ pub mod insert { text.push_str(&indent); (range.head, range.head, Some(text.into())) }); - view.doc.apply(&transaction); + cx.view.doc.apply(&transaction); } // TODO: handle indent-aware delete - pub fn delete_char_backward(view: &mut View, count: usize) { - let text = &view.doc.text().slice(..); - let transaction = Transaction::change_by_selection(&view.doc.state, |range| { + pub fn delete_char_backward(cx: &mut Context) { + let text = &cx.view.doc.text().slice(..); + let transaction = Transaction::change_by_selection(&cx.view.doc.state, |range| { ( - graphemes::nth_prev_grapheme_boundary(text, range.head, count), + graphemes::nth_prev_grapheme_boundary(text, range.head, cx.count), range.head, None, ) }); - view.doc.apply(&transaction); + cx.view.doc.apply(&transaction); } - pub fn delete_char_forward(view: &mut View, count: usize) { - let text = &view.doc.text().slice(..); - let transaction = Transaction::change_by_selection(&view.doc.state, |range| { + pub fn delete_char_forward(cx: &mut Context) { + let text = &cx.view.doc.text().slice(..); + let transaction = Transaction::change_by_selection(&cx.view.doc.state, |range| { ( range.head, - graphemes::nth_next_grapheme_boundary(text, range.head, count), + graphemes::nth_next_grapheme_boundary(text, range.head, cx.count), None, ) }); - view.doc.apply(&transaction); + cx.view.doc.apply(&transaction); } } @@ -495,31 +518,32 @@ pub fn insert_char_prompt(prompt: &mut Prompt, c: char) { // Undo / Redo -pub fn undo(view: &mut View, _count: usize) { - if let Some(revert) = view.doc.history.undo() { - view.doc.version += 1; - view.doc.apply(&revert); +pub fn undo(cx: &mut Context) { + if let Some(revert) = cx.view.doc.history.undo() { + cx.view.doc.version += 1; + cx.view.doc.apply(&revert); } // TODO: each command could simply return a Option, then the higher level handles storing it? } -pub fn redo(view: &mut View, _count: usize) { - if let Some(transaction) = view.doc.history.redo() { - view.doc.version += 1; - view.doc.apply(&transaction); +pub fn redo(cx: &mut Context) { + if let Some(transaction) = cx.view.doc.history.redo() { + cx.view.doc.version += 1; + cx.view.doc.apply(&transaction); } } // Yank / Paste -pub fn yank(view: &mut View, _count: usize) { +pub fn yank(cx: &mut Context) { // TODO: should selections be made end inclusive? - let values = view + let values = cx + .view .doc .state .selection() - .fragments(&view.doc.text().slice(..)) + .fragments(&cx.view.doc.text().slice(..)) .map(|cow| cow.into_owned()) .collect(); @@ -528,7 +552,7 @@ pub fn yank(view: &mut View, _count: usize) { register::set(reg, values); } -pub fn paste(view: &mut View, _count: usize) { +pub fn paste(cx: &mut Context) { // TODO: allow specifying reg let reg = '"'; if let Some(values) = register::get(reg) { @@ -560,19 +584,19 @@ pub fn paste(view: &mut View, _count: usize) { let transaction = if linewise { // paste on the next line // TODO: can simply take a range + modifier and compute the right pos without ifs - let text = view.doc.text(); - Transaction::change_by_selection(&view.doc.state, |range| { + let text = cx.view.doc.text(); + Transaction::change_by_selection(&cx.view.doc.state, |range| { let line_end = text.line_to_char(text.char_to_line(range.head) + 1); (line_end, line_end, Some(values.next().unwrap())) }) } else { - Transaction::change_by_selection(&view.doc.state, |range| { + Transaction::change_by_selection(&cx.view.doc.state, |range| { (range.head + 1, range.head + 1, Some(values.next().unwrap())) }) }; - view.doc.apply(&transaction); - append_changes_to_history(view); + cx.view.doc.apply(&transaction); + append_changes_to_history(cx); } } @@ -593,29 +617,29 @@ fn get_lines(view: &View) -> Vec { lines } -pub fn indent(view: &mut View, _count: usize) { - let lines = get_lines(view); +pub fn indent(cx: &mut Context) { + let lines = get_lines(cx.view); // Indent by one level let indent = Tendril::from(" ".repeat(TAB_WIDTH)); let transaction = Transaction::change( - &view.doc.state, + &cx.view.doc.state, lines.into_iter().map(|line| { - let pos = view.doc.text().line_to_char(line); + let pos = cx.view.doc.text().line_to_char(line); (pos, pos, Some(indent.clone())) }), ); - view.doc.apply(&transaction); - append_changes_to_history(view); + cx.view.doc.apply(&transaction); + append_changes_to_history(cx); } -pub fn unindent(view: &mut View, _count: usize) { - let lines = get_lines(view); +pub fn unindent(cx: &mut Context) { + let lines = get_lines(cx.view); let mut changes = Vec::with_capacity(lines.len()); for line_idx in lines { - let line = view.doc.text().line(line_idx); + let line = cx.view.doc.text().line(line_idx); let mut width = 0; for ch in line.chars() { @@ -631,18 +655,18 @@ pub fn unindent(view: &mut View, _count: usize) { } if width > 0 { - let start = view.doc.text().line_to_char(line_idx); + let start = cx.view.doc.text().line_to_char(line_idx); changes.push((start, start + width, None)) } } - let transaction = Transaction::change(&view.doc.state, changes.into_iter()); + let transaction = Transaction::change(&cx.view.doc.state, changes.into_iter()); - view.doc.apply(&transaction); - append_changes_to_history(view); + cx.view.doc.apply(&transaction); + append_changes_to_history(cx); } -pub fn indent_selection(_view: &mut View, _count: usize) { +pub fn indent_selection(_cx: &mut Context) { // loop over each line and recompute proper indentation unimplemented!() } From 3f707c19f46284d745568c632a57103eb1be4dd4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Hrastnik?= Date: Fri, 30 Oct 2020 17:00:30 +0900 Subject: [PATCH 21/23] Save command --- Cargo.lock | 1 + helix-term/src/main.rs | 12 +++--------- helix-view/Cargo.toml | 2 ++ helix-view/src/commands.rs | 12 ++++++++++-- helix-view/src/document.rs | 25 +++++++++++++++++++++++++ 5 files changed, 41 insertions(+), 11 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 28fc503cb..e89696adf 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -523,6 +523,7 @@ dependencies = [ "crossterm", "helix-core", "once_cell", + "smol", "tui", "url", ] diff --git a/helix-term/src/main.rs b/helix-term/src/main.rs index f91c1c8f4..9378d3eef 100644 --- a/helix-term/src/main.rs +++ b/helix-term/src/main.rs @@ -70,16 +70,10 @@ fn main() -> Result<(), Error> { std::thread::spawn(move || smol::block_on(EX.run(smol::future::pending::<()>()))); } - // let mut lsp = helix_lsp::Client::start(&EX, "rust-analyzer", &[]); + let mut app = Application::new(args, &EX).unwrap(); - smol::block_on(async { - // let res = lsp.initialize().await; - // let state = helix_core::State::load("test.rs".into(), &[]).unwrap(); - // let res = lsp.text_document_did_open(&state).await; - // loop {} - - Application::new(args, &EX).unwrap().run().await; - }); + // we use the thread local executor to spawn the application task separately from the work pool + smol::block_on(app.run()); Ok(()) } diff --git a/helix-view/Cargo.toml b/helix-view/Cargo.toml index 9d53f929d..0a48b7217 100644 --- a/helix-view/Cargo.toml +++ b/helix-view/Cargo.toml @@ -20,3 +20,5 @@ tui = { git = "https://github.com/fdehau/tui-rs", default-features = false, feat crossterm = { version = "0.18", features = ["event-stream"], optional = true} once_cell = "1.4" url = "2" + +smol = "1" diff --git a/helix-view/src/commands.rs b/helix-view/src/commands.rs index 26c7a1901..c135a3da2 100644 --- a/helix-view/src/commands.rs +++ b/helix-view/src/commands.rs @@ -331,8 +331,7 @@ pub fn append_mode(cx: &mut Context) { } // TODO: I, A, o and O can share a lot of the primitives. - -pub fn command_mode(_view: &mut View, _count: usize) { +pub fn command_mode(_cx: &mut Context) { unimplemented!() } @@ -670,3 +669,12 @@ pub fn indent_selection(_cx: &mut Context) { // loop over each line and recompute proper indentation unimplemented!() } + +// + +pub fn save(cx: &mut Context) { + // Spawns an async task to actually do the saving. This way we prevent blocking. + + // TODO: handle save errors somehow? + cx.executor.spawn(cx.view.doc.save()).detach(); +} diff --git a/helix-view/src/document.rs b/helix-view/src/document.rs index 710ea4f83..1587de8b5 100644 --- a/helix-view/src/document.rs +++ b/helix-view/src/document.rs @@ -1,4 +1,5 @@ use anyhow::Error; +use std::future::Future; use std::path::PathBuf; use helix_core::{ @@ -97,6 +98,30 @@ impl Document { Ok(doc) } + pub fn save(&self) -> impl Future> { + // we clone and move text + path into the future so that we asynchronously save the current + // state without blocking any further edits. + + let text = self.text().clone(); + let path = self.path.clone().expect("Can't save with no path set!"); // TODO: handle no path + + // TODO: mark changes up to now as saved + // TODO: mark dirty false + + async move { + use smol::{fs::File, prelude::*}; + let mut file = File::create(path).await?; + + // write all the rope chunks to file + for chunk in text.chunks() { + file.write_all(chunk.as_bytes()).await?; + } + // TODO: flush? + + Ok(()) + } // and_then(// lsp.send_text_saved_notification()) + } + pub fn set_language(&mut self, scope: &str, scopes: &[String]) { if let Some(language_config) = LOADER.language_config_for_scope(scope) { let highlight_config = language_config.highlight_config(scopes).unwrap().unwrap(); From a7869c728c663f255d5d2544e42f21ccf57b2414 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Hrastnik?= Date: Thu, 5 Nov 2020 15:15:19 +0900 Subject: [PATCH 22/23] wip --- Cargo.lock | 68 ++++++++++++++++------------------- helix-core/src/syntax.rs | 4 +++ helix-lsp/Cargo.toml | 1 + helix-lsp/src/lib.rs | 53 +++++++++++++++++++++++++++ helix-term/src/application.rs | 14 ++++++-- helix-view/src/document.rs | 15 ++++++++ 6 files changed, 115 insertions(+), 40 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index e89696adf..c9e421a28 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2,24 +2,18 @@ # It is not intended for manual editing. [[package]] name = "aho-corasick" -version = "0.7.14" +version = "0.7.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b476ce7103678b0c6d3d395dbbae31d48ff910bd28be979ba5d48c6351131d0d" +checksum = "7404febffaa47dac81aa44dba71523c9d069b1bdc50a77db41195149e17f68e5" dependencies = [ "memchr", ] [[package]] name = "anyhow" -version = "1.0.33" +version = "1.0.34" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a1fd36ffbb1fb7c834eac128ea8d0e310c5aeb635548f9d58861e1308d46e71c" - -[[package]] -name = "arc-swap" -version = "0.4.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4d25d88fd6b8041580a654f9d0c581a047baee2b3efee13275f2fc392fc75034" +checksum = "bf8dcb5b4bbaa28653b647d8c77bd4ed40183b48882e130c1f1ffb73de069fd7" [[package]] name = "arrayref" @@ -158,9 +152,9 @@ checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693" [[package]] name = "blake2b_simd" -version = "0.5.10" +version = "0.5.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d8fb2d74254a3a0b5cac33ac9f8ed0e44aa50378d9dbb2e5d83bd21ed1dc2c8a" +checksum = "afa748e348ad3be8263be728124b24a24f268266f6f5d58af9d75f6a40b5c587" dependencies = [ "arrayref", "arrayvec", @@ -279,9 +273,9 @@ dependencies = [ [[package]] name = "crossterm" -version = "0.18.1" +version = "0.18.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cef9149b29071d44c9fb98fd9c27fcf74405bbdb761889ad6a03f36be93b0b15" +checksum = "4e86d73f2a0b407b5768d10a8c720cf5d2df49a9efc10ca09176d201ead4b7fb" dependencies = [ "bitflags", "crossterm_winapi", @@ -479,6 +473,7 @@ dependencies = [ "jsonrpc-core", "log", "lsp-types", + "once_cell", "pathdiff", "serde", "serde_json", @@ -653,15 +648,15 @@ checksum = "7ffc5c5338469d4d3ea17d269fa8ea3512ad247247c30bd2df69e68309ed0a08" [[package]] name = "memchr" -version = "2.3.3" +version = "2.3.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3728d817d99e5ac407411fa471ff9800a778d88a24685968b36824eaf4bee400" +checksum = "0ee1c47aaa256ecabcaea351eae4a9b01ef39ed810004e298d2511ed284b1525" [[package]] name = "mio" -version = "0.7.4" +version = "0.7.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8f1c83949125de4a582aa2da15ae6324d91cf6a58a70ea407643941ff98f558" +checksum = "8962c171f57fcfffa53f4df1bb15ec4c8cf26a7569459c9ceb62d94aab0d9584" dependencies = [ "libc", "log", @@ -707,9 +702,9 @@ dependencies = [ [[package]] name = "num-integer" -version = "0.1.43" +version = "0.1.44" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8d59457e662d541ba17869cf51cf177c0b5f0cbf476c66bdc90bf1edac4f875b" +checksum = "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db" dependencies = [ "autocfg", "num-traits", @@ -717,9 +712,9 @@ dependencies = [ [[package]] name = "num-traits" -version = "0.2.12" +version = "0.2.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac267bcc07f48ee5f8935ab0d24f316fb722d7a1292e2913f0cc196b29ffd611" +checksum = "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290" dependencies = [ "autocfg", ] @@ -837,9 +832,9 @@ dependencies = [ [[package]] name = "proc-macro-hack" -version = "0.5.18" +version = "0.5.19" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "99c605b9a0adc77b7211c6b1f722dcb613d68d66859a44f3d485a6da332b0598" +checksum = "dbf0c48bc1d91375ae5c3cd81e3722dff1abcf81a30960240640d223f59fe0e5" [[package]] name = "proc-macro-nested" @@ -884,9 +879,9 @@ dependencies = [ [[package]] name = "regex" -version = "1.4.1" +version = "1.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8963b85b8ce3074fecffde43b4b0dded83ce2f367dc8d363afc56679f3ee820b" +checksum = "38cf2c13ed4745de91a5eb834e11c00bcc3709e773173b2ce4c56c9fbde04b9c" dependencies = [ "aho-corasick", "memchr", @@ -896,9 +891,9 @@ dependencies = [ [[package]] name = "regex-syntax" -version = "0.6.20" +version = "0.6.21" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8cab7a364d15cde1e505267766a2d3c4e22a843e1a601f0fa7564c0f82ced11c" +checksum = "3b181ba2dcf07aaccad5448e8ead58db5b742cf85dfe035e2227f137a539a189" [[package]] name = "ropey" @@ -997,11 +992,10 @@ dependencies = [ [[package]] name = "signal-hook-registry" -version = "1.2.1" +version = "1.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a3e12110bc539e657a646068aaf5eb5b63af9d0c1f7b29c97113fad80e15f035" +checksum = "ce32ea0c6c56d5eacaeb814fbed9960547021d3edd010ded1425f180536b20ab" dependencies = [ - "arc-swap", "libc", ] @@ -1079,18 +1073,18 @@ dependencies = [ [[package]] name = "thiserror" -version = "1.0.21" +version = "1.0.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "318234ffa22e0920fe9a40d7b8369b5f649d490980cf7aadcf1eb91594869b42" +checksum = "0e9ae34b84616eedaaf1e9dd6026dbe00dcafa92aa0c8077cb69df1fcfe5e53e" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" -version = "1.0.21" +version = "1.0.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cae2447b6282786c3493999f40a9be2a6ad20cb8bd268b0a0dbf5a065535c0ab" +checksum = "9ba20f23e85b10754cd195504aebf6a27e2e6cbe28c17778a0c930724628dd56" dependencies = [ "proc-macro2", "quote", @@ -1125,9 +1119,9 @@ checksum = "238ce071d267c5710f9d31451efec16c5ee22de34df17cc05e56cbc92e967117" [[package]] name = "tree-sitter" -version = "0.17.0" +version = "0.17.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "70ee7370fec3aecde3862a7d64c571048f70a7298daef1815e8fc68b9de54b5c" +checksum = "d18dcb776d3affaba6db04d11d645946d34a69b3172e588af96ce9fecd20faac" dependencies = [ "cc", "regex", diff --git a/helix-core/src/syntax.rs b/helix-core/src/syntax.rs index f4826fb45..70d42c475 100644 --- a/helix-core/src/syntax.rs +++ b/helix-core/src/syntax.rs @@ -62,6 +62,10 @@ impl LanguageConfiguration { }) .map(Option::as_ref) } + + pub fn scope(&self) -> &str { + &self.scope + } } use once_cell::sync::Lazy; diff --git a/helix-lsp/Cargo.toml b/helix-lsp/Cargo.toml index 0c5d8b918..08216f59c 100644 --- a/helix-lsp/Cargo.toml +++ b/helix-lsp/Cargo.toml @@ -9,6 +9,7 @@ edition = "2018" [dependencies] helix-core = { path = "../helix-core" } helix-view = { path = "../helix-view" } +once_cell = "1.4" lsp-types = { version = "0.83", features = ["proposed"] } smol = "1.2" diff --git a/helix-lsp/src/lib.rs b/helix-lsp/src/lib.rs index 1ee8199f4..8353ef7d7 100644 --- a/helix-lsp/src/lib.rs +++ b/helix-lsp/src/lib.rs @@ -4,11 +4,15 @@ mod transport; pub use jsonrpc_core as jsonrpc; pub use lsp_types as lsp; +pub use once_cell::sync::{Lazy, OnceCell}; + pub use client::Client; pub use lsp::{Position, Url}; use thiserror::Error; +use std::{collections::HashMap, sync::Arc}; + #[derive(Error, Debug)] pub enum Error { #[error("protocol error: {0}")] @@ -62,3 +66,52 @@ impl Notification { } pub use jsonrpc::Call; + +type LanguageId = String; + +pub static REGISTRY: Lazy = Lazy::new(Registry::init); + +pub struct Registry { + inner: HashMap>>, +} + +impl Registry { + pub fn init() -> Self { + Self { + inner: HashMap::new(), + } + } + + pub fn get(&self, id: &str, ex: &smol::Executor) -> Option> { + // TODO: use get_or_try_init and propagate the error + self.inner + .get(id) + .map(|cell| { + cell.get_or_init(|| { + // TODO: lookup defaults for id (name, args) + + // initialize a new client + let client = Client::start(&ex, "rust-analyzer", &[]); + // TODO: also call initialize().await() + Arc::new(client) + }) + }) + .cloned() + } +} + +// REGISTRY = HashMap>> +// spawn one server per language type, need to spawn one per workspace if server doesn't support +// workspaces +// +// could also be a client per root dir +// +// storing a copy of Option>> on Document would make the LSP client easily +// accessible during edit/save callbacks +// +// the event loop needs to process all incoming streams, maybe we can just have that be a separate +// task that's continually running and store the state on the client, then use read lock to +// retrieve data during render +// -> PROBLEM: how do you trigger an update on the editor side when data updates? +// +// -> The data updates should pull all events until we run out so we don't frequently re-render diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs index cacfde56a..141779ecc 100644 --- a/helix-term/src/application.rs +++ b/helix-term/src/application.rs @@ -636,9 +636,17 @@ impl<'a> Application<'a> { } } Some(Call::MethodCall(call)) => { - // TODO: need to make Result - - unimplemented!("{:?}", call) + debug!("Method not found {}", call.method); + + self.language_server.reply( + call.id, + // TODO: make a Into trait that can cast to Err(jsonrpc::Error) + Err(helix_lsp::jsonrpc::Error { + code: helix_lsp::jsonrpc::ErrorCode::MethodNotFound, + message: "Method not found".to_string(), + data: None, + }), + ); } _ => unreachable!(), } diff --git a/helix-view/src/document.rs b/helix-view/src/document.rs index 1587de8b5..e8f311c51 100644 --- a/helix-view/src/document.rs +++ b/helix-view/src/document.rs @@ -25,6 +25,8 @@ pub struct Document { /// Tree-sitter AST tree pub syntax: Option, + /// Corresponding language scope name. Usually `source.`. + pub language: Option, /// Pending changes since last history commit. pub changes: ChangeSet, @@ -64,6 +66,7 @@ impl Document { mode: Mode::Normal, restore_cursor: false, syntax: None, + language: None, changes, old_state, diagnostics: Vec::new(), @@ -73,6 +76,7 @@ impl Document { } // TODO: passing scopes here is awkward + // TODO: async fn? pub fn load(path: PathBuf, scopes: &[String]) -> Result { use std::{env, fs::File, io::BufReader}; let _current_dir = env::current_dir()?; @@ -90,6 +94,15 @@ impl Document { let syntax = Syntax::new(&doc.state.doc, highlight_config.clone()); doc.syntax = Some(syntax); + // TODO: maybe just keep an Arc<> pointer to the language_config? + doc.language = Some(language_config.scope().to_string()); + + // TODO: this ties lsp support to tree-sitter enabled languages for now. Language + // config should use Option to let us have non-tree-sitter configs. + + // TODO: circular dep: view <-> lsp + // helix_lsp::REGISTRY; + // view should probably depend on lsp }; // canonicalize path to absolute value @@ -98,6 +111,8 @@ impl Document { Ok(doc) } + // TODO: do we need some way of ensuring two save operations on the same doc can't run at once? + // or is that handled by the OS/async layer pub fn save(&self) -> impl Future> { // we clone and move text + path into the future so that we asynchronously save the current // state without blocking any further edits. From 39bf1ca82514e1dc56dfebdce2558cce662367d1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Hrastnik?= Date: Tue, 1 Dec 2020 09:53:17 +0900 Subject: [PATCH 23/23] Update deps. --- Cargo.lock | 150 ++++++++++++++++++++++--------------- helix-lsp/Cargo.toml | 2 +- helix-lsp/src/client.rs | 3 +- helix-lsp/src/lib.rs | 2 +- helix-view/src/document.rs | 2 +- 5 files changed, 93 insertions(+), 66 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index c9e421a28..a3e93bd7b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -40,9 +40,9 @@ dependencies = [ [[package]] name = "async-executor" -version = "1.3.0" +version = "1.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d373d78ded7d0b3fa8039375718cde0aace493f2e34fb60f51cbf567562ca801" +checksum = "eb877970c7b440ead138f6321a3b5395d6061183af779340b65e20c0fede9146" dependencies = [ "async-task", "concurrent-queue", @@ -65,9 +65,9 @@ dependencies = [ [[package]] name = "async-io" -version = "1.1.10" +version = "1.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d54bc4c1c7292475efb2253227dbcfad8fe1ca4c02bc62c510cc2f3da5c4704e" +checksum = "9315f8f07556761c3e48fec2e6b276004acf426e6dc068b2c2251854d65ee0fd" dependencies = [ "concurrent-queue", "fastrand", @@ -144,6 +144,12 @@ version = "0.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3441f0f7b02788e948e47f457ca01f1d7e6d92c693bc132c22b087d3141c03ff" +[[package]] +name = "base64" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd" + [[package]] name = "bitflags" version = "1.2.1" @@ -189,9 +195,9 @@ checksum = "df8670b8c7b9dae1793364eafadf7239c40d669904660c5960d74cfd80b46a53" [[package]] name = "cc" -version = "1.0.61" +version = "1.0.65" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ed67cbde08356238e75fc4656be4749481eeffb09e19f320a25237d5221c985d" +checksum = "95752358c8f7552394baf48cd82695b345628ad3f170d607de3ca03b8dacca15" dependencies = [ "jobserver", ] @@ -262,12 +268,12 @@ checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc" [[package]] name = "crossbeam-utils" -version = "0.7.2" +version = "0.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c3c7c73a2d1e9fc0886a08b93e98eb643461230d5f1925e4036204d5f2e261a8" +checksum = "02d96d1e189ef58269ebe5b97953da3274d83a93af647c2ddd6f9dab28cedb8d" dependencies = [ "autocfg", - "cfg-if 0.1.10", + "cfg-if 1.0.0", "lazy_static", ] @@ -342,6 +348,16 @@ dependencies = [ "log", ] +[[package]] +name = "form_urlencoded" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ece68d15c92e84fa4f19d3780f1294e5ca82a78a6d515f1efaabcc144688be00" +dependencies = [ + "matches", + "percent-encoding", +] + [[package]] name = "futf" version = "0.1.4" @@ -360,15 +376,15 @@ checksum = "4c7e4c2612746b0df8fed4ce0c69156021b704c9aefa360311c04e6e9e002eed" [[package]] name = "futures-core" -version = "0.3.7" +version = "0.3.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "18eaa56102984bed2c88ea39026cff3ce3b4c7f508ca970cedf2450ea10d4e46" +checksum = "847ce131b72ffb13b6109a221da9ad97a64cbe48feb1028356b836b47b8f1748" [[package]] name = "futures-io" -version = "0.3.7" +version = "0.3.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6e1798854a4727ff944a7b12aa999f58ce7aa81db80d2dfaaf2ba06f065ddd2b" +checksum = "611834ce18aaa1bd13c4b374f5d653e1027cf99b6b502584ff8c9a64413b30bb" [[package]] name = "futures-lite" @@ -387,9 +403,9 @@ dependencies = [ [[package]] name = "futures-macro" -version = "0.3.7" +version = "0.3.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e36fccf3fc58563b4a14d265027c627c3b665d7fed489427e88e7cc929559efe" +checksum = "77408a692f1f97bcc61dc001d752e00643408fbc922e4d634c655df50d595556" dependencies = [ "proc-macro-hack", "proc-macro2", @@ -399,18 +415,18 @@ dependencies = [ [[package]] name = "futures-task" -version = "0.3.7" +version = "0.3.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "96d502af37186c4fef99453df03e374683f8a1eec9dcc1e66b3b82dc8278ce3c" +checksum = "7c554eb5bf48b2426c4771ab68c6b14468b6e76cc90996f528c3338d761a4d0d" dependencies = [ "once_cell", ] [[package]] name = "futures-util" -version = "0.3.7" +version = "0.3.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "abcb44342f62e6f3e8ac427b8aa815f724fd705dfad060b18ac7866c15bb8e34" +checksum = "d304cff4a7b99cfb7986f7d43fbe93d175e72e704a8860787cc95e9ffd85cbd2" dependencies = [ "futures-core", "futures-macro", @@ -555,9 +571,9 @@ dependencies = [ [[package]] name = "instant" -version = "0.1.8" +version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cb1fc4429a33e1f80d41dc9fea4d108a88bec1de8053878898ae448a0b52f613" +checksum = "61124eeebbd69b8190558df225adf7e4caafce0d743919e5d6b19652314ec5ec" dependencies = [ "cfg-if 1.0.0", ] @@ -604,9 +620,9 @@ checksum = "4d58d1b70b004888f764dfbf6a26a3b0342a1632d33968e4a179d8011c760614" [[package]] name = "lock_api" -version = "0.4.1" +version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "28247cc5a5be2f05fbcd76dd0cf2c7d3b5400cb978a28042abcd4fa0b3f8261c" +checksum = "dd96ffd135b2fd7b973ac026d28085defbe8983df057ced3eb4f2130b0831312" dependencies = [ "scopeguard", ] @@ -622,11 +638,11 @@ dependencies = [ [[package]] name = "lsp-types" -version = "0.83.0" +version = "0.84.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "25e0bd4b95038f2c23bda332ba0ca684e8dda765db1f9bdb63dc4c3e01f3b456" +checksum = "3b95be71fe205e44de754185bcf86447b65813ce1ceb298f8d3793ade5fff08d" dependencies = [ - "base64", + "base64 0.12.3", "bitflags", "serde", "serde_json", @@ -654,9 +670,9 @@ checksum = "0ee1c47aaa256ecabcaea351eae4a9b01ef39ed810004e298d2511ed284b1525" [[package]] name = "mio" -version = "0.7.5" +version = "0.7.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8962c171f57fcfffa53f4df1bb15ec4c8cf26a7569459c9ceb62d94aab0d9584" +checksum = "f33bc887064ef1fd66020c9adfc45bb9f33d75a42096c81e7c56c65b75dd1a8b" dependencies = [ "libc", "log", @@ -667,9 +683,9 @@ dependencies = [ [[package]] name = "miow" -version = "0.3.5" +version = "0.3.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07b88fb9795d4d36d62a012dfbf49a8f5cf12751f36d31a9dbe66d528e58979e" +checksum = "5a33c1b55807fbed163481b5ba66db4b2fa6cde694a5027be10fb724206c5897" dependencies = [ "socket2", "winapi", @@ -731,15 +747,15 @@ dependencies = [ [[package]] name = "once_cell" -version = "1.4.1" +version = "1.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "260e51e7efe62b592207e9e13a68e43692a7a279171d6ba57abd208bf23645ad" +checksum = "13bd41f508810a131401606d54ac32a467c97172d74ba7662562ebba5ad07fa0" [[package]] name = "os_str_bytes" -version = "2.3.2" +version = "2.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2ac6fe3538f701e339953a3ebbe4f39941aababa8a3f6964635b24ab526daeac" +checksum = "afb2e1c3ee07430c2cf76151675e583e0f19985fa6efae47d6848a3e2c824f85" [[package]] name = "parking" @@ -749,9 +765,9 @@ checksum = "427c3892f9e783d91cc128285287e70a59e206ca452770ece88a76f7a3eddd72" [[package]] name = "parking_lot" -version = "0.11.0" +version = "0.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a4893845fa2ca272e647da5d0e46660a314ead9c2fdd9a883aabc32e481a8733" +checksum = "6d7744ac029df22dca6284efe4e898991d28e3085c706c972bcd7da4a27a15eb" dependencies = [ "instant", "lock_api", @@ -787,18 +803,18 @@ checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e" [[package]] name = "pin-project" -version = "1.0.1" +version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ee41d838744f60d959d7074e3afb6b35c7456d0f61cad38a24e35e6553f73841" +checksum = "9ccc2237c2c489783abd8c4c80e5450fc0e98644555b1364da68cc29aa151ca7" dependencies = [ "pin-project-internal", ] [[package]] name = "pin-project-internal" -version = "1.0.1" +version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "81a4ffa594b66bff340084d4081df649a7dc049ac8d7fc458d8e628bfbbb2f86" +checksum = "f8e8d2bf0b23038a4424865103a4df472855692821aab4e4f5c3312d461d9e5f" dependencies = [ "proc-macro2", "quote", @@ -906,11 +922,11 @@ dependencies = [ [[package]] name = "rust-argon2" -version = "0.8.2" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9dab61250775933275e84053ac235621dfb739556d5c54a2f2e9313b7cf43a19" +checksum = "4b18820d944b33caa75a71378964ac46f58517c92b6ae5f762636247c09e78fb" dependencies = [ - "base64", + "base64 0.13.0", "blake2b_simd", "constant_time_eq", "crossbeam-utils", @@ -1007,15 +1023,15 @@ checksum = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8" [[package]] name = "smallvec" -version = "1.4.2" +version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fbee7696b84bbf3d89a1c2eccff0850e3047ed46bfcd2e92c29a2d074d57e252" +checksum = "7acad6f34eb9e8a259d3283d1e8c1d34d7415943d4895f65cc73813c7396fc85" [[package]] name = "smol" -version = "1.2.4" +version = "1.2.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aaf8ded16994c0ae59596c6e4733c76faeb0533c26fd5ca1b1bc89271a049a66" +checksum = "85cf3b5351f3e783c1d79ab5fc604eeed8b8ae9abd36b166e8b87a089efd85e4" dependencies = [ "async-channel", "async-executor", @@ -1031,11 +1047,11 @@ dependencies = [ [[package]] name = "socket2" -version = "0.3.15" +version = "0.3.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b1fa70dc5c8104ec096f4fe7ede7a221d35ae13dcd19ba1ad9a81d2cab9a1c44" +checksum = "2c29947abdee2a218277abeca306f25789c938e500ea5a9d4b12a5a504466902" dependencies = [ - "cfg-if 0.1.10", + "cfg-if 1.0.0", "libc", "redox_syscall", "winapi", @@ -1043,9 +1059,9 @@ dependencies = [ [[package]] name = "syn" -version = "1.0.48" +version = "1.0.53" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cc371affeffc477f42a221a1e4297aedcea33d47d19b61455588bd9d8f6b19ac" +checksum = "8833e20724c24de12bbaba5ad230ea61c3eafb05b881c7c9d3cfe8638b187e68" dependencies = [ "proc-macro2", "quote", @@ -1113,9 +1129,18 @@ dependencies = [ [[package]] name = "tinyvec" -version = "0.3.4" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ccf8dbc19eb42fba10e8feaaec282fb50e2c14b2726d6301dbfeed0f73306a6f" +dependencies = [ + "tinyvec_macros", +] + +[[package]] +name = "tinyvec_macros" +version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "238ce071d267c5710f9d31451efec16c5ee22de34df17cc05e56cbc92e967117" +checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c" [[package]] name = "tree-sitter" @@ -1129,8 +1154,8 @@ dependencies = [ [[package]] name = "tui" -version = "0.12.0" -source = "git+https://github.com/fdehau/tui-rs#25ff2e5e61f8902101e485743992db2412f77aad" +version = "0.13.0" +source = "git+https://github.com/fdehau/tui-rs#efdd6bfb193dafcb5e3bdc75e7d2d314065da1d7" dependencies = [ "bitflags", "cassowary", @@ -1150,18 +1175,18 @@ dependencies = [ [[package]] name = "unicode-normalization" -version = "0.1.13" +version = "0.1.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6fb19cf769fa8c6a80a162df694621ebeb4dafb606470b2b2fce0be40a98a977" +checksum = "a13e63ab62dbe32aeee58d1c5408d35c36c392bba5d9d3142287219721afe606" dependencies = [ "tinyvec", ] [[package]] name = "unicode-segmentation" -version = "1.6.0" +version = "1.7.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e83e153d1053cbb5a118eeff7fd5be06ed99153f00dbcd8ae310c5fb2b22edc0" +checksum = "bb0d2e7be6ae3a5fa87eed5fb451aff96f2573d2694942e40543ae0bbe19c796" [[package]] name = "unicode-width" @@ -1177,10 +1202,11 @@ checksum = "f7fe0bb3479651439c9112f72b6c505038574c9fbb575ed1bf3b797fa39dd564" [[package]] name = "url" -version = "2.1.1" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "829d4a8476c35c9bf0bbce5a3b23f4106f79728039b726d292bb93bc106787cb" +checksum = "5909f2b0817350449ed73e8bcd81c8c3c8d9a7a5d8acba4b27db277f1868976e" dependencies = [ + "form_urlencoded", "idna", "matches", "percent-encoding", diff --git a/helix-lsp/Cargo.toml b/helix-lsp/Cargo.toml index 08216f59c..2ecd0cc12 100644 --- a/helix-lsp/Cargo.toml +++ b/helix-lsp/Cargo.toml @@ -11,7 +11,7 @@ helix-core = { path = "../helix-core" } helix-view = { path = "../helix-view" } once_cell = "1.4" -lsp-types = { version = "0.83", features = ["proposed"] } +lsp-types = { version = "0.84", features = ["proposed"] } smol = "1.2" url = "2" pathdiff = "0.2" diff --git a/helix-lsp/src/client.rs b/helix-lsp/src/client.rs index 1583bfb84..1f07cf897 100644 --- a/helix-lsp/src/client.rs +++ b/helix-lsp/src/client.rs @@ -183,7 +183,7 @@ impl Client { #[allow(deprecated)] let params = lsp::InitializeParams { - process_id: Some(u64::from(std::process::id())), + process_id: Some(std::process::id()), root_path: None, // root_uri: Some(lsp_types::Url::parse("file://localhost/")?), root_uri: None, // set to project root in the future @@ -194,6 +194,7 @@ impl Client { trace: None, workspace_folders: None, client_info: None, + locale: None, // TODO }; let response = self.request::(params).await?; diff --git a/helix-lsp/src/lib.rs b/helix-lsp/src/lib.rs index 8353ef7d7..eae6fa868 100644 --- a/helix-lsp/src/lib.rs +++ b/helix-lsp/src/lib.rs @@ -38,7 +38,7 @@ pub mod util { let line_start = doc.char_to_utf16_cu(line); let col = doc.char_to_utf16_cu(pos) - line_start; - lsp::Position::new(line as u64, col as u64) + lsp::Position::new(line as u32, col as u32) } } diff --git a/helix-view/src/document.rs b/helix-view/src/document.rs index e8f311c51..7c4596ad5 100644 --- a/helix-view/src/document.rs +++ b/helix-view/src/document.rs @@ -32,7 +32,7 @@ pub struct Document { pub changes: ChangeSet, pub old_state: State, pub history: History, - pub version: i64, // should be usize? + pub version: i32, // should be usize? pub diagnostics: Vec, }