Add support for path completion (#2608)

Co-authored-by: Michael Davis <mcarsondavis@gmail.com>
Co-authored-by: Pascal Kuthe <pascalkuthe@pm.me>

Cargo.lock

@@ -1346,6 +1346,8 @@ dependencies = [
  "bitflags",
  "dunce",
  "etcetera",
+ "once_cell",
+ "regex-automata",
  "regex-cursor",
  "ropey",
  "rustix",

book/src/editor.md

@@ -33,6 +33,7 @@
 | `cursorcolumn` | Highlight all columns with a cursor | `false` |
 | `gutters` | Gutters to display: Available are `diagnostics` and `diff` and `line-numbers` and `spacer`, note that `diagnostics` also includes other features like breakpoints, 1-width padding will be inserted if gutters is non-empty | `["diagnostics", "spacer", "line-numbers", "spacer", "diff"]` |
 | `auto-completion` | Enable automatic pop up of auto-completion | `true` |
+| `path-completion` | Enable filepath completion. Show files and directories if an existing path at the cursor was recognized, either absolute or relative to the current opened document or current working directory (if the buffer is not yet saved). Defaults to true. | `true` |
 | `auto-format` | Enable automatic formatting on save | `true` |
 | `idle-timeout` | Time in milliseconds since last keypress before idle timers trigger. | `250` |
 | `completion-timeout` | Time in milliseconds after typing a word character before completions are shown, set to 5 for instant.  | `250` |

book/src/languages.md

@@ -69,6 +69,7 @@ These configuration keys are available:
 | `formatter`           | The formatter for the language, it will take precedence over the lsp when defined. The formatter must be able to take the original file as input from stdin and write the formatted file to stdout |
 | `soft-wrap` | [editor.softwrap](./configuration.md#editorsoft-wrap-section)
 | `text-width`          |  Maximum line length. Used for the `:reflow` command and soft-wrapping if `soft-wrap.wrap-at-text-width` is set, defaults to `editor.text-width`   |
+| `path-completion`     | Overrides the `editor.path-completion` config key for the language. |
 | `workspace-lsp-roots`     | Directories relative to the workspace root that are treated as LSP roots. Should only be set in `.helix/config.toml`. Overwrites the setting of the same name in `config.toml` if set. |
 | `persistent-diagnostic-sources` | An array of LSP diagnostic sources assumed unchanged when the language server resends the same set of diagnostics. Helix can track the position for these diagnostics internally instead. Useful for diagnostics that are recomputed on save.
 

helix-core/src/completion.rs

@@ -0,0 +1,12 @@
+use std::borrow::Cow;
+
+use crate::Transaction;
+
+#[derive(Debug, PartialEq, Clone)]
+pub struct CompletionItem {
+    pub transaction: Transaction,
+    pub label: Cow<'static, str>,
+    pub kind: Cow<'static, str>,
+    /// Containing Markdown
+    pub documentation: String,
+}

helix-core/src/lib.rs

@@ -3,6 +3,7 @@ pub use encoding_rs as encoding;
 pub mod auto_pairs;
 pub mod chars;
 pub mod comment;
+pub mod completion;
 pub mod config;
 pub mod diagnostic;
 pub mod diff;
@@ -63,6 +64,7 @@ pub use selection::{Range, Selection};
 pub use smallvec::{smallvec, SmallVec};
 pub use syntax::Syntax;
 
+pub use completion::CompletionItem;
 pub use diagnostic::Diagnostic;
 
 pub use line_ending::{LineEnding, NATIVE_LINE_ENDING};

helix-core/src/syntax.rs

@@ -125,6 +125,9 @@ pub struct LanguageConfiguration {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub formatter: Option<FormatterConfiguration>,
 
+    /// If set, overrides `editor.path-completion`.
+    pub path_completion: Option<bool>,
+
     #[serde(default)]
     pub diagnostic_severity: Severity,
 

helix-event/src/cancel.rs

@@ -1,15 +1,18 @@
+use std::borrow::Borrow;
 use std::future::Future;
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::Relaxed;
+use std::sync::Arc;
 
-pub use oneshot::channel as cancelation;
-use tokio::sync::oneshot;
+use tokio::sync::Notify;
 
-pub type CancelTx = oneshot::Sender<()>;
-pub type CancelRx = oneshot::Receiver<()>;
-
-pub async fn cancelable_future<T>(future: impl Future<Output = T>, cancel: CancelRx) -> Option<T> {
+pub async fn cancelable_future<T>(
+    future: impl Future<Output = T>,
+    cancel: impl Borrow<TaskHandle>,
+) -> Option<T> {
     tokio::select! {
         biased;
-        _ = cancel => {
+        _ = cancel.borrow().canceled() => {
             None
         }
         res = future => {
@@ -17,3 +20,268 @@ pub async fn cancelable_future<T>(future: impl Future<Output = T>, cancel: Cance
         }
     }
 }
+
+#[derive(Default, Debug)]
+struct Shared {
+    state: AtomicU64,
+    // `Notify` has some features that we don't really need here because it
+    // supports waking single tasks (`notify_one`) and does its own (more
+    // complicated) state tracking, we could reimplement the waiter linked list
+    // with modest effort and reduce memory consumption by one word/8 bytes and
+    // reduce code complexity/number of atomic operations.
+    //
+    // I don't think that's worth the complexity (unsafe code).
+    //
+    // if we only cared about async code then we could also only use a notify
+    // (without the generation count), this would be equivalent (or maybe more
+    // correct if we want to allow cloning the TX) but it would be extremly slow
+    // to frequently check for cancelation from sync code
+    notify: Notify,
+}
+
+impl Shared {
+    fn generation(&self) -> u32 {
+        self.state.load(Relaxed) as u32
+    }
+
+    fn num_running(&self) -> u32 {
+        (self.state.load(Relaxed) >> 32) as u32
+    }
+
+    /// Increments the generation count and sets `num_running`
+    /// to the provided value, this operation is not with
+    /// regard to the generation counter (doesn't use `fetch_add`)
+    /// so the calling code must ensure it cannot execute concurrently
+    /// to maintain correctness (but not safety)
+    fn inc_generation(&self, num_running: u32) -> (u32, u32) {
+        let state = self.state.load(Relaxed);
+        let generation = state as u32;
+        let prev_running = (state >> 32) as u32;
+        // no need to create a new generation if the refcount is zero (fastpath)
+        if prev_running == 0 && num_running == 0 {
+            return (generation, 0);
+        }
+        let new_generation = generation.saturating_add(1);
+        self.state.store(
+            new_generation as u64 | ((num_running as u64) << 32),
+            Relaxed,
+        );
+        self.notify.notify_waiters();
+        (new_generation, prev_running)
+    }
+
+    fn inc_running(&self, generation: u32) {
+        let mut state = self.state.load(Relaxed);
+        loop {
+            let current_generation = state as u32;
+            if current_generation != generation {
+                break;
+            }
+            let off = 1 << 32;
+            let res = self.state.compare_exchange_weak(
+                state,
+                state.saturating_add(off),
+                Relaxed,
+                Relaxed,
+            );
+            match res {
+                Ok(_) => break,
+                Err(new_state) => state = new_state,
+            }
+        }
+    }
+
+    fn dec_running(&self, generation: u32) {
+        let mut state = self.state.load(Relaxed);
+        loop {
+            let current_generation = state as u32;
+            if current_generation != generation {
+                break;
+            }
+            let num_running = (state >> 32) as u32;
+            // running can't be zero here, that would mean we miscounted somewhere
+            assert_ne!(num_running, 0);
+            let off = 1 << 32;
+            let res = self
+                .state
+                .compare_exchange_weak(state, state - off, Relaxed, Relaxed);
+            match res {
+                Ok(_) => break,
+                Err(new_state) => state = new_state,
+            }
+        }
+    }
+}
+
+// This intentionally doesn't implement `Clone` and requires a mutable reference
+// for cancelation to avoid races (in inc_generation).
+
+/// A task controller allows managing a single subtask enabling the controller
+/// to cancel the subtask and to check whether it is still running.
+///
+/// For efficiency reasons the controller can be reused/restarted,
+/// in that case the previous task is automatically canceled.
+///
+/// If the controller is dropped, the subtasks are automatically canceled.
+#[derive(Default, Debug)]
+pub struct TaskController {
+    shared: Arc<Shared>,
+}
+
+impl TaskController {
+    pub fn new() -> Self {
+        TaskController::default()
+    }
+    /// Cancels the active task (handle).
+    ///
+    /// Returns whether any tasks were still running before the cancelation.
+    pub fn cancel(&mut self) -> bool {
+        self.shared.inc_generation(0).1 != 0
+    }
+
+    /// Checks whether there are any task handles
+    /// that haven't been dropped (or canceled) yet.
+    pub fn is_running(&self) -> bool {
+        self.shared.num_running() != 0
+    }
+
+    /// Starts a new task and cancels the previous task (handles).
+    pub fn restart(&mut self) -> TaskHandle {
+        TaskHandle {
+            generation: self.shared.inc_generation(1).0,
+            shared: self.shared.clone(),
+        }
+    }
+}
+
+impl Drop for TaskController {
+    fn drop(&mut self) {
+        self.cancel();
+    }
+}
+
+/// A handle that is used to link a task with a task controller.
+///
+/// It can be used to cancel async futures very efficiently but can also be checked for
+/// cancelation very quickly (single atomic read) in blocking code.
+/// The handle can be cheaply cloned (reference counted).
+///
+/// The TaskController can check whether a task is "running" by inspecting the
+/// refcount of the (current) tasks handles. Therefore, if that information
+/// is important, ensure that the handle is not dropped until the task fully
+/// completes.
+pub struct TaskHandle {
+    shared: Arc<Shared>,
+    generation: u32,
+}
+
+impl Clone for TaskHandle {
+    fn clone(&self) -> Self {
+        self.shared.inc_running(self.generation);
+        TaskHandle {
+            shared: self.shared.clone(),
+            generation: self.generation,
+        }
+    }
+}
+
+impl Drop for TaskHandle {
+    fn drop(&mut self) {
+        self.shared.dec_running(self.generation);
+    }
+}
+
+impl TaskHandle {
+    /// Waits until [`TaskController::cancel`] is called for the corresponding
+    /// [`TaskController`]. Immediately returns if `cancel` was already called since
+    pub async fn canceled(&self) {
+        let notified = self.shared.notify.notified();
+        if !self.is_canceled() {
+            notified.await
+        }
+    }
+
+    pub fn is_canceled(&self) -> bool {
+        self.generation != self.shared.generation()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::future::poll_fn;
+
+    use futures_executor::block_on;
+    use tokio::task::yield_now;
+
+    use crate::{cancelable_future, TaskController};
+
+    #[test]
+    fn immediate_cancel() {
+        let mut controller = TaskController::new();
+        let handle = controller.restart();
+        controller.cancel();
+        assert!(handle.is_canceled());
+        controller.restart();
+        assert!(handle.is_canceled());
+
+        let res = block_on(cancelable_future(
+            poll_fn(|_cx| std::task::Poll::Ready(())),
+            handle,
+        ));
+        assert!(res.is_none());
+    }
+
+    #[test]
+    fn running_count() {
+        let mut controller = TaskController::new();
+        let handle = controller.restart();
+        assert!(controller.is_running());
+        assert!(!handle.is_canceled());
+        drop(handle);
+        assert!(!controller.is_running());
+        assert!(!controller.cancel());
+        let handle = controller.restart();
+        assert!(!handle.is_canceled());
+        assert!(controller.is_running());
+        let handle2 = handle.clone();
+        assert!(!handle.is_canceled());
+        assert!(controller.is_running());
+        drop(handle2);
+        assert!(!handle.is_canceled());
+        assert!(controller.is_running());
+        assert!(controller.cancel());
+        assert!(handle.is_canceled());
+        assert!(!controller.is_running());
+    }
+
+    #[test]
+    fn no_cancel() {
+        let mut controller = TaskController::new();
+        let handle = controller.restart();
+        assert!(!handle.is_canceled());
+
+        let res = block_on(cancelable_future(
+            poll_fn(|_cx| std::task::Poll::Ready(())),
+            handle,
+        ));
+        assert!(res.is_some());
+    }
+
+    #[test]
+    fn delayed_cancel() {
+        let mut controller = TaskController::new();
+        let handle = controller.restart();
+
+        let mut hit = false;
+        let res = block_on(cancelable_future(
+            async {
+                controller.cancel();
+                hit = true;
+                yield_now().await;
+            },
+            handle,
+        ));
+        assert!(res.is_none());
+        assert!(hit);
+    }
+}

helix-event/src/lib.rs

@@ -32,7 +32,7 @@
 //! to helix-view in the future if we manage to detach the compositor from its rendering backend.
 
 use anyhow::Result;
-pub use cancel::{cancelable_future, cancelation, CancelRx, CancelTx};
+pub use cancel::{cancelable_future, TaskController, TaskHandle};
 pub use debounce::{send_blocking, AsyncHook};
 pub use redraw::{
     lock_frame, redraw_requested, request_redraw, start_frame, RenderLockGuard, RequestRedrawOnDrop,

helix-stdx/Cargo.toml

@@ -18,6 +18,8 @@ ropey = { version = "1.6.1", default-features = false }
 which = "7.0"
 regex-cursor = "0.1.4"
 bitflags = "2.6"
+once_cell = "1.19"
+regex-automata = "0.4.8"
 
 [target.'cfg(windows)'.dependencies]
 windows-sys = { version = "0.59", features = ["Win32_Foundation", "Win32_Security", "Win32_Security_Authorization", "Win32_Storage_FileSystem", "Win32_System_Threading"] }

helix-stdx/src/env.rs

@@ -1,9 +1,12 @@
 use std::{
-    ffi::OsStr,
+    borrow::Cow,
+    ffi::{OsStr, OsString},
     path::{Path, PathBuf},
     sync::RwLock,
 };
 
+use once_cell::sync::Lazy;
+
 static CWD: RwLock<Option<PathBuf>> = RwLock::new(None);
 
 // Get the current working directory.
@@ -59,6 +62,93 @@ pub fn which<T: AsRef<OsStr>>(
     })
 }
 
+fn find_brace_end(src: &[u8]) -> Option<usize> {
+    use regex_automata::meta::Regex;
+
+    static REGEX: Lazy<Regex> = Lazy::new(|| Regex::builder().build("[{}]").unwrap());
+    let mut depth = 0;
+    for mat in REGEX.find_iter(src) {
+        let pos = mat.start();
+        match src[pos] {
+            b'{' => depth += 1,
+            b'}' if depth == 0 => return Some(pos),
+            b'}' => depth -= 1,
+            _ => unreachable!(),
+        }
+    }
+    None
+}
+
+fn expand_impl(src: &OsStr, mut resolve: impl FnMut(&OsStr) -> Option<OsString>) -> Cow<OsStr> {
+    use regex_automata::meta::Regex;
+
+    static REGEX: Lazy<Regex> = Lazy::new(|| {
+        Regex::builder()
+            .build_many(&[
+                r"\$\{([^\}:]+):-",
+                r"\$\{([^\}:]+):=",
+                r"\$\{([^\}-]+)-",
+                r"\$\{([^\}=]+)=",
+                r"\$\{([^\}]+)",
+                r"\$(\w+)",
+            ])
+            .unwrap()
+    });
+
+    let bytes = src.as_encoded_bytes();
+    let mut res = Vec::with_capacity(bytes.len());
+    let mut pos = 0;
+    for captures in REGEX.captures_iter(bytes) {
+        let mat = captures.get_match().unwrap();
+        let pattern_id = mat.pattern().as_usize();
+        let mut range = mat.range();
+        let var = &bytes[captures.get_group(1).unwrap().range()];
+        let default = if pattern_id != 5 {
+            let Some(bracket_pos) = find_brace_end(&bytes[range.end..]) else {
+                break;
+            };
+            let default = &bytes[range.end..range.end + bracket_pos];
+            range.end += bracket_pos + 1;
+            default
+        } else {
+            &[]
+        };
+        // safety: this is a codepoint aligned substring of an osstr (always valid)
+        let var = unsafe { OsStr::from_encoded_bytes_unchecked(var) };
+        let expansion = resolve(var);
+        let expansion = match &expansion {
+            Some(val) => {
+                if val.is_empty() && pattern_id < 2 {
+                    default
+                } else {
+                    val.as_encoded_bytes()
+                }
+            }
+            None => default,
+        };
+        res.extend_from_slice(&bytes[pos..range.start]);
+        pos = range.end;
+        res.extend_from_slice(expansion);
+    }
+    if pos == 0 {
+        src.into()
+    } else {
+        res.extend_from_slice(&bytes[pos..]);
+        // safety: this is a composition of valid osstr (and codepoint aligned slices which are also valid)
+        unsafe { OsString::from_encoded_bytes_unchecked(res) }.into()
+    }
+}
+
+/// performs substitution of enviorment variables. Supports the following (POSIX) syntax:
+///
+/// * `$<var>`, `${<var>}`
+/// * `${<var>:-<default>}`, `${<var>-<default>}`
+/// * `${<var>:=<default>}`, `${<var>=default}`
+///
+pub fn expand<S: AsRef<OsStr> + ?Sized>(src: &S) -> Cow<OsStr> {
+    expand_impl(src.as_ref(), |var| std::env::var_os(var))
+}
+
 #[derive(Debug)]
 pub struct ExecutableNotFoundError {
     command: String,
@@ -75,7 +165,9 @@ impl std::error::Error for ExecutableNotFoundError {}
 
 #[cfg(test)]
 mod tests {
-    use super::{current_working_dir, set_current_working_dir};
+    use std::ffi::{OsStr, OsString};
+
+    use super::{current_working_dir, expand_impl, set_current_working_dir};
 
     #[test]
     fn current_dir_is_set() {
@@ -88,4 +180,34 @@ mod tests {
         let cwd = current_working_dir();
         assert_eq!(cwd, new_path);
     }
+
+    macro_rules! assert_env_expand {
+        ($env: expr, $lhs: expr, $rhs: expr) => {
+            assert_eq!(&*expand_impl($lhs.as_ref(), $env), OsStr::new($rhs));
+        };
+    }
+
+    /// paths that should work on all platforms
+    #[test]
+    fn test_env_expand() {
+        let env = |var: &OsStr| -> Option<OsString> {
+            match var.to_str().unwrap() {
+                "FOO" => Some("foo".into()),
+                "EMPTY" => Some("".into()),
+                _ => None,
+            }
+        };
+        assert_env_expand!(env, "pass_trough", "pass_trough");
+        assert_env_expand!(env, "$FOO", "foo");
+        assert_env_expand!(env, "bar/$FOO/baz", "bar/foo/baz");
+        assert_env_expand!(env, "bar/${FOO}/baz", "bar/foo/baz");
+        assert_env_expand!(env, "baz/${BAR:-bar}/foo", "baz/bar/foo");
+        assert_env_expand!(env, "baz/${BAR:=bar}/foo", "baz/bar/foo");
+        assert_env_expand!(env, "baz/${BAR-bar}/foo", "baz/bar/foo");
+        assert_env_expand!(env, "baz/${BAR=bar}/foo", "baz/bar/foo");
+        assert_env_expand!(env, "baz/${EMPTY:-bar}/foo", "baz/bar/foo");
+        assert_env_expand!(env, "baz/${EMPTY:=bar}/foo", "baz/bar/foo");
+        assert_env_expand!(env, "baz/${EMPTY-bar}/foo", "baz//foo");
+        assert_env_expand!(env, "baz/${EMPTY=bar}/foo", "baz//foo");
+    }
 }

helix-stdx/src/path.rs

@@ -1,8 +1,12 @@
 pub use etcetera::home_dir;
+use once_cell::sync::Lazy;
+use regex_cursor::{engines::meta::Regex, Input};
+use ropey::RopeSlice;
 
 use std::{
     borrow::Cow,
     ffi::OsString,
+    ops::Range,
     path::{Component, Path, PathBuf, MAIN_SEPARATOR_STR},
 };
 
@@ -51,7 +55,7 @@ where
 
 /// Normalize a path without resolving symlinks.
 // Strategy: start from the first component and move up. Cannonicalize previous path,
-// join component, cannonicalize new path, strip prefix and join to the final result.
+// join component, canonicalize new path, strip prefix and join to the final result.
 pub fn normalize(path: impl AsRef<Path>) -> PathBuf {
     let mut components = path.as_ref().components().peekable();
     let mut ret = if let Some(c @ Component::Prefix(..)) = components.peek().cloned() {
@@ -201,6 +205,96 @@ pub fn get_truncated_path(path: impl AsRef<Path>) -> PathBuf {
     ret
 }
 
+fn path_component_regex(windows: bool) -> String {
+    // TODO: support backslash path escape on windows (when using git bash for example)
+    let space_escape = if windows { r"[\^`]\s" } else { r"[\\]\s" };
+    // partially baesd on what's allowed in an url but with some care to avoid
+    // false positivies (like any kind of brackets or quotes)
+    r"[\w@.\-+#$%?!,;~&]|".to_owned() + space_escape
+}
+
+/// Regex for delimited environment captures like `${HOME}`.
+fn braced_env_regex(windows: bool) -> String {
+    r"\$\{(?:".to_owned() + &path_component_regex(windows) + r"|[/:=])+\}"
+}
+
+fn compile_path_regex(
+    prefix: &str,
+    postfix: &str,
+    match_single_file: bool,
+    windows: bool,
+) -> Regex {
+    let first_component = format!(
+        "(?:{}|(?:{}))",
+        braced_env_regex(windows),
+        path_component_regex(windows)
+    );
+    // For all components except the first we allow an equals so that `foo=/
+    // bar/baz` does not include foo. This is primarily intended for url queries
+    // (where an equals is never in the first component)
+    let component = format!("(?:{first_component}|=)");
+    let sep = if windows { r"[/\\]" } else { "/" };
+    let url_prefix = r"[\w+\-.]+://??";
+    let path_prefix = if windows {
+        // single slash handles most windows prefixes (like\\server\...) but `\
+        // \?\C:\..` (and C:\) needs special handling, since we don't allow : in path
+        // components (so that colon separated paths and <path>:<line> work)
+        r"\\\\\?\\\w:|\w:|\\|"
+    } else {
+        ""
+    };
+    let path_start = format!("(?:{first_component}+|~|{path_prefix}{url_prefix})");
+    let optional = if match_single_file {
+        format!("|{path_start}")
+    } else {
+        String::new()
+    };
+    let path_regex = format!(
+        "{prefix}(?:{path_start}?(?:(?:{sep}{component}+)+{sep}?|{sep}){optional}){postfix}"
+    );
+    Regex::new(&path_regex).unwrap()
+}
+
+/// If `src` ends with a path then this function returns the part of the slice.
+pub fn get_path_suffix(src: RopeSlice<'_>, match_single_file: bool) -> Option<RopeSlice<'_>> {
+    let regex = if match_single_file {
+        static REGEX: Lazy<Regex> = Lazy::new(|| compile_path_regex("", "$", true, cfg!(windows)));
+        &*REGEX
+    } else {
+        static REGEX: Lazy<Regex> = Lazy::new(|| compile_path_regex("", "$", false, cfg!(windows)));
+        &*REGEX
+    };
+
+    regex
+        .find(Input::new(src))
+        .map(|mat| src.byte_slice(mat.range()))
+}
+
+/// Returns an iterator of the **byte** ranges in src that contain a path.
+pub fn find_paths(
+    src: RopeSlice<'_>,
+    match_single_file: bool,
+) -> impl Iterator<Item = Range<usize>> + '_ {
+    let regex = if match_single_file {
+        static REGEX: Lazy<Regex> = Lazy::new(|| compile_path_regex("", "", true, cfg!(windows)));
+        &*REGEX
+    } else {
+        static REGEX: Lazy<Regex> = Lazy::new(|| compile_path_regex("", "", false, cfg!(windows)));
+        &*REGEX
+    };
+    regex.find_iter(Input::new(src)).map(|mat| mat.range())
+}
+
+/// Performs substitution of `~` and environment variables, see [`env::expand`](crate::env::expand) and [`expand_tilde`]
+pub fn expand<T: AsRef<Path> + ?Sized>(path: &T) -> Cow<'_, Path> {
+    let path = path.as_ref();
+    let path = expand_tilde(path);
+    match crate::env::expand(&*path) {
+        Cow::Borrowed(_) => path,
+        Cow::Owned(path) => PathBuf::from(path).into(),
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::{
@@ -208,7 +302,10 @@ mod tests {
         path::{Component, Path},
     };
 
-    use crate::path;
+    use regex_cursor::Input;
+    use ropey::RopeSlice;
+
+    use crate::path::{self, compile_path_regex};
 
     #[test]
     fn expand_tilde() {
@@ -228,4 +325,127 @@ mod tests {
             assert_ne!(component_count, 0);
         }
     }
+
+    macro_rules! assert_match {
+        ($regex: expr, $haystack: expr) => {
+            let haystack = Input::new(RopeSlice::from($haystack));
+            assert!(
+                $regex.is_match(haystack),
+                "regex should match {}",
+                $haystack
+            );
+        };
+    }
+    macro_rules! assert_no_match {
+        ($regex: expr, $haystack: expr) => {
+            let haystack = Input::new(RopeSlice::from($haystack));
+            assert!(
+                !$regex.is_match(haystack),
+                "regex should not match {}",
+                $haystack
+            );
+        };
+    }
+
+    macro_rules! assert_matches {
+        ($regex: expr, $haystack: expr, [$($matches: expr),*]) => {
+            let src = $haystack;
+            let matches: Vec<_> = $regex
+                .find_iter(Input::new(RopeSlice::from(src)))
+                .map(|it| &src[it.range()])
+                .collect();
+            assert_eq!(matches, vec![$($matches),*]);
+        };
+    }
+
+    /// Linux-only path
+    #[test]
+    fn path_regex_unix() {
+        // due to ambiguity with the `\` path separator we can't support space escapes `\ ` on windows
+        let regex = compile_path_regex("^", "$", false, false);
+        assert_match!(regex, "${FOO}/hello\\ world");
+        assert_match!(regex, "${FOO}/\\ ");
+    }
+
+    /// Windows-only paths
+    #[test]
+    fn path_regex_windows() {
+        let regex = compile_path_regex("^", "$", false, true);
+        assert_match!(regex, "${FOO}/hello^ world");
+        assert_match!(regex, "${FOO}/hello` world");
+        assert_match!(regex, "${FOO}/^ ");
+        assert_match!(regex, "${FOO}/` ");
+        assert_match!(regex, r"foo\bar");
+        assert_match!(regex, r"foo\bar");
+        assert_match!(regex, r"..\bar");
+        assert_match!(regex, r"..\");
+        assert_match!(regex, r"C:\");
+        assert_match!(regex, r"\\?\C:\foo");
+        assert_match!(regex, r"\\server\foo");
+    }
+
+    /// Paths that should work on all platforms
+    #[test]
+    fn path_regex() {
+        for windows in [false, true] {
+            let regex = compile_path_regex("^", "$", false, windows);
+            assert_no_match!(regex, "foo");
+            assert_no_match!(regex, "");
+            assert_match!(regex, "https://github.com/notifications/query=foo");
+            assert_match!(regex, "file:///foo/bar");
+            assert_match!(regex, "foo/bar");
+            assert_match!(regex, "$HOME/foo");
+            assert_match!(regex, "${FOO:-bar}/baz");
+            assert_match!(regex, "foo/bar_");
+            assert_match!(regex, "/home/bar");
+            assert_match!(regex, "foo/");
+            assert_match!(regex, "./");
+            assert_match!(regex, "../");
+            assert_match!(regex, "../..");
+            assert_match!(regex, "./foo");
+            assert_match!(regex, "./foo.rs");
+            assert_match!(regex, "/");
+            assert_match!(regex, "~/");
+            assert_match!(regex, "~/foo");
+            assert_match!(regex, "~/foo");
+            assert_match!(regex, "~/foo/../baz");
+            assert_match!(regex, "${HOME}/foo");
+            assert_match!(regex, "$HOME/foo");
+            assert_match!(regex, "/$FOO");
+            assert_match!(regex, "/${FOO}");
+            assert_match!(regex, "/${FOO}/${BAR}");
+            assert_match!(regex, "/${FOO}/${BAR}/foo");
+            assert_match!(regex, "/${FOO}/${BAR}");
+            assert_match!(regex, "${FOO}/hello_$WORLD");
+            assert_match!(regex, "${FOO}/hello_${WORLD}");
+            let regex = compile_path_regex("", "", false, windows);
+            assert_no_match!(regex, "");
+            assert_matches!(
+                regex,
+                r#"${FOO}/hello_${WORLD}  ${FOO}/hello_${WORLD} foo("./bar", "/home/foo")""#,
+                [
+                    "${FOO}/hello_${WORLD}",
+                    "${FOO}/hello_${WORLD}",
+                    "./bar",
+                    "/home/foo"
+                ]
+            );
+            assert_matches!(
+                regex,
+                r#"--> helix-stdx/src/path.rs:427:13"#,
+                ["helix-stdx/src/path.rs"]
+            );
+            assert_matches!(
+                regex,
+                r#"PATH=/foo/bar:/bar/baz:${foo:-/foo}/bar:${PATH}"#,
+                ["/foo/bar", "/bar/baz", "${foo:-/foo}/bar"]
+            );
+            let regex = compile_path_regex("^", "$", true, windows);
+            assert_no_match!(regex, "");
+            assert_match!(regex, "foo");
+            assert_match!(regex, "foo/");
+            assert_match!(regex, "$FOO");
+            assert_match!(regex, "${BAR}");
+        }
+    }
 }

helix-term/src/commands.rs

@@ -6,7 +6,7 @@ pub use dap::*;
 use futures_util::FutureExt;
 use helix_event::status;
 use helix_stdx::{
-    path::expand_tilde,
+    path::{self, find_paths},
     rope::{self, RopeSliceExt},
 };
 use helix_vcs::{FileChange, Hunk};
@@ -1272,53 +1272,31 @@ fn goto_file_impl(cx: &mut Context, action: Action) {
         .unwrap_or_default();
 
     let paths: Vec<_> = if selections.len() == 1 && primary.len() == 1 {
-        // Secial case: if there is only one one-width selection, try to detect the
-        // path under the cursor.
-        let is_valid_path_char = |c: &char| {
-            #[cfg(target_os = "windows")]
-            let valid_chars = &[
-                '@', '/', '\\', '.', '-', '_', '+', '#', '$', '%', '{', '}', '[', ']', ':', '!',
-                '~', '=',
-            ];
-            #[cfg(not(target_os = "windows"))]
-            let valid_chars = &['@', '/', '.', '-', '_', '+', '#', '$', '%', '~', '=', ':'];
-
-            valid_chars.contains(c) || c.is_alphabetic() || c.is_numeric()
-        };
-
-        let cursor_pos = primary.cursor(text.slice(..));
-        let pre_cursor_pos = cursor_pos.saturating_sub(1);
-        let post_cursor_pos = cursor_pos + 1;
-        let start_pos = if is_valid_path_char(&text.char(cursor_pos)) {
-            cursor_pos
-        } else if is_valid_path_char(&text.char(pre_cursor_pos)) {
-            pre_cursor_pos
-        } else {
-            post_cursor_pos
-        };
-
-        let prefix_len = text
-            .chars_at(start_pos)
-            .reversed()
-            .take_while(is_valid_path_char)
-            .count();
-
-        let postfix_len = text
-            .chars_at(start_pos)
-            .take_while(is_valid_path_char)
-            .count();
-
-        let path: String = text
-            .slice((start_pos - prefix_len)..(start_pos + postfix_len))
-            .into();
-        log::debug!("goto_file auto-detected path: {}", path);
-
-        vec![path]
+        let mut pos = primary.cursor(text.slice(..));
+        pos = text.char_to_byte(pos);
+        let search_start = text
+            .line_to_byte(text.byte_to_line(pos))
+            .max(pos.saturating_sub(1000));
+        let search_end = text
+            .line_to_byte(text.byte_to_line(pos) + 1)
+            .min(pos + 1000);
+        let search_range = text.slice(search_start..search_end);
+        // we also allow paths that are next to the cursor (can be ambigous but
+        // rarely so in practice) so that gf on quoted/braced path works (not sure about this
+        // but apparently that is how gf has worked historically in helix)
+        let path = find_paths(search_range, true)
+            .inspect(|mat| println!("{mat:?} {:?}", pos - search_start))
+            .take_while(|range| search_start + range.start <= pos + 1)
+            .find(|range| pos <= search_start + range.end)
+            .map(|range| Cow::from(search_range.byte_slice(range)));
+        log::debug!("goto_file auto-detected path: {path:?}");
+        let path = path.unwrap_or_else(|| primary.fragment(text.slice(..)));
+        vec![path.into_owned()]
     } else {
         // Otherwise use each selection, trimmed.
         selections
             .fragments(text.slice(..))
-            .map(|sel| sel.trim().to_string())
+            .map(|sel| sel.trim().to_owned())
             .filter(|sel| !sel.is_empty())
             .collect()
     };
@@ -1329,7 +1307,7 @@ fn goto_file_impl(cx: &mut Context, action: Action) {
             continue;
         }
 
-        let path = expand_tilde(Cow::from(PathBuf::from(sel)));
+        let path = path::expand(&sel);
         let path = &rel_path.join(path);
         if path.is_dir() {
             let picker = ui::file_picker(path.into(), &cx.editor.config());

helix-term/src/handlers/completion.rs

@@ -4,20 +4,20 @@ use std::time::Duration;
 
 use arc_swap::ArcSwap;
 use futures_util::stream::FuturesUnordered;
+use futures_util::FutureExt;
 use helix_core::chars::char_is_word;
 use helix_core::syntax::LanguageServerFeature;
-use helix_event::{
-    cancelable_future, cancelation, register_hook, send_blocking, CancelRx, CancelTx,
-};
+use helix_event::{cancelable_future, register_hook, send_blocking, TaskController, TaskHandle};
 use helix_lsp::lsp;
 use helix_lsp::util::pos_to_lsp_pos;
 use helix_stdx::rope::RopeSliceExt;
 use helix_view::document::{Mode, SavePoint};
 use helix_view::handlers::lsp::CompletionEvent;
 use helix_view::{DocumentId, Editor, ViewId};
+use path::path_completion;
 use tokio::sync::mpsc::Sender;
 use tokio::time::Instant;
-use tokio_stream::StreamExt;
+use tokio_stream::StreamExt as _;
 
 use crate::commands;
 use crate::compositor::Compositor;
@@ -27,10 +27,13 @@ use crate::job::{dispatch, dispatch_blocking};
 use crate::keymap::MappableCommand;
 use crate::ui::editor::InsertEvent;
 use crate::ui::lsp::SignatureHelp;
-use crate::ui::{self, CompletionItem, Popup};
+use crate::ui::{self, Popup};
 
 use super::Handlers;
+pub use item::{CompletionItem, LspCompletionItem};
 pub use resolve::ResolveHandler;
+mod item;
+mod path;
 mod resolve;
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
@@ -53,12 +56,8 @@ pub(super) struct CompletionHandler {
     /// currently active trigger which will cause a
     /// completion request after the timeout
     trigger: Option<Trigger>,
-    /// A handle for currently active completion request.
-    /// This can be used to determine whether the current
-    /// request is still active (and new triggers should be
-    /// ignored) and can also be used to abort the current
-    /// request (by dropping the handle)
-    request: Option<CancelTx>,
+    in_flight: Option<Trigger>,
+    task_controller: TaskController,
     config: Arc<ArcSwap<Config>>,
 }
 
@@ -66,8 +65,9 @@ impl CompletionHandler {
     pub fn new(config: Arc<ArcSwap<Config>>) -> CompletionHandler {
         Self {
             config,
-            request: None,
+            task_controller: TaskController::new(),
             trigger: None,
+            in_flight: None,
         }
     }
 }
@@ -80,6 +80,9 @@ impl helix_event::AsyncHook for CompletionHandler {
         event: Self::Event,
         _old_timeout: Option<Instant>,
     ) -> Option<Instant> {
+        if self.in_flight.is_some() && !self.task_controller.is_running() {
+            self.in_flight = None;
+        }
         match event {
             CompletionEvent::AutoTrigger {
                 cursor: trigger_pos,
@@ -90,7 +93,7 @@ impl helix_event::AsyncHook for CompletionHandler {
                 // but people may create weird keymaps/use the mouse so lets be extra careful
                 if self
                     .trigger
-                    .as_ref()
+                    .or(self.in_flight)
                     .map_or(true, |trigger| trigger.doc != doc || trigger.view != view)
                 {
                     self.trigger = Some(Trigger {
@@ -103,7 +106,7 @@ impl helix_event::AsyncHook for CompletionHandler {
             }
             CompletionEvent::TriggerChar { cursor, doc, view } => {
                 // immediately request completions and drop all auto completion requests
-                self.request = None;
+                self.task_controller.cancel();
                 self.trigger = Some(Trigger {
                     pos: cursor,
                     view,
@@ -113,7 +116,6 @@ impl helix_event::AsyncHook for CompletionHandler {
             }
             CompletionEvent::ManualTrigger { cursor, doc, view } => {
                 // immediately request completions and drop all auto completion requests
-                self.request = None;
                 self.trigger = Some(Trigger {
                     pos: cursor,
                     view,
@@ -126,21 +128,21 @@ impl helix_event::AsyncHook for CompletionHandler {
             }
             CompletionEvent::Cancel => {
                 self.trigger = None;
-                self.request = None;
+                self.task_controller.cancel();
             }
             CompletionEvent::DeleteText { cursor } => {
                 // if we deleted the original trigger, abort the completion
-                if matches!(self.trigger, Some(Trigger{ pos, .. }) if cursor < pos) {
+                if matches!(self.trigger.or(self.in_flight), Some(Trigger{ pos, .. }) if cursor < pos)
+                {
                     self.trigger = None;
-                    self.request = None;
+                    self.task_controller.cancel();
                 }
             }
         }
         self.trigger.map(|trigger| {
             // if the current request was closed forget about it
             // otherwise immediately restart the completion request
-            let cancel = self.request.take().map_or(false, |req| !req.is_closed());
-            let timeout = if trigger.kind == TriggerKind::Auto && !cancel {
+            let timeout = if trigger.kind == TriggerKind::Auto {
                 self.config.load().editor.completion_timeout
             } else {
                 // we want almost instant completions for trigger chars
@@ -155,17 +157,17 @@ impl helix_event::AsyncHook for CompletionHandler {
 
     fn finish_debounce(&mut self) {
         let trigger = self.trigger.take().expect("debounce always has a trigger");
-        let (tx, rx) = cancelation();
-        self.request = Some(tx);
+        self.in_flight = Some(trigger);
+        let handle = self.task_controller.restart();
         dispatch_blocking(move |editor, compositor| {
-            request_completion(trigger, rx, editor, compositor)
+            request_completion(trigger, handle, editor, compositor)
         });
     }
 }
 
 fn request_completion(
     mut trigger: Trigger,
-    cancel: CancelRx,
+    handle: TaskHandle,
     editor: &mut Editor,
     compositor: &mut Compositor,
 ) {
@@ -251,15 +253,19 @@ fn request_completion(
                     None => Vec::new(),
                 }
                 .into_iter()
-                .map(|item| CompletionItem {
+                .map(|item| {
+                    CompletionItem::Lsp(LspCompletionItem {
                         item,
                         provider: language_server_id,
                         resolved: false,
                     })
+                })
                 .collect();
                 anyhow::Ok(items)
             }
+            .boxed()
         })
+        .chain(path_completion(cursor, text.clone(), doc, handle.clone()))
         .collect();
 
     let future = async move {
@@ -280,12 +286,13 @@ fn request_completion(
     let ui = compositor.find::<ui::EditorView>().unwrap();
     ui.last_insert.1.push(InsertEvent::RequestCompletion);
     tokio::spawn(async move {
-        let items = cancelable_future(future, cancel).await.unwrap_or_default();
-        if items.is_empty() {
+        let items = cancelable_future(future, &handle).await;
+        let Some(items) = items.filter(|items| !items.is_empty()) else {
             return;
-        }
+        };
         dispatch(move |editor, compositor| {
-            show_completion(editor, compositor, items, trigger, savepoint)
+            show_completion(editor, compositor, items, trigger, savepoint);
+            drop(handle)
         })
         .await
     });
@@ -346,7 +353,17 @@ pub fn trigger_auto_completion(
                         ..
                     }) if triggers.iter().any(|trigger| text.ends_with(trigger)))
         });
-    if is_trigger_char {
+
+    let cursor_char = text
+        .get_bytes_at(text.len_bytes())
+        .and_then(|t| t.reversed().next());
+
+    #[cfg(windows)]
+    let is_path_completion_trigger = matches!(cursor_char, Some(b'/' | b'\\'));
+    #[cfg(not(windows))]
+    let is_path_completion_trigger = matches!(cursor_char, Some(b'/'));
+
+    if is_trigger_char || (is_path_completion_trigger && doc.path_completion_enabled()) {
         send_blocking(
             tx,
             CompletionEvent::TriggerChar {

helix-term/src/handlers/completion/item.rs

@@ -0,0 +1,41 @@
+use helix_lsp::{lsp, LanguageServerId};
+
+#[derive(Debug, PartialEq, Clone)]
+pub struct LspCompletionItem {
+    pub item: lsp::CompletionItem,
+    pub provider: LanguageServerId,
+    pub resolved: bool,
+}
+
+#[derive(Debug, PartialEq, Clone)]
+pub enum CompletionItem {
+    Lsp(LspCompletionItem),
+    Other(helix_core::CompletionItem),
+}
+
+impl PartialEq<CompletionItem> for LspCompletionItem {
+    fn eq(&self, other: &CompletionItem) -> bool {
+        match other {
+            CompletionItem::Lsp(other) => self == other,
+            _ => false,
+        }
+    }
+}
+
+impl PartialEq<CompletionItem> for helix_core::CompletionItem {
+    fn eq(&self, other: &CompletionItem) -> bool {
+        match other {
+            CompletionItem::Other(other) => self == other,
+            _ => false,
+        }
+    }
+}
+
+impl CompletionItem {
+    pub fn preselect(&self) -> bool {
+        match self {
+            CompletionItem::Lsp(LspCompletionItem { item, .. }) => item.preselect.unwrap_or(false),
+            CompletionItem::Other(_) => false,
+        }
+    }
+}

helix-term/src/handlers/completion/path.rs

@@ -0,0 +1,189 @@
+use std::{
+    borrow::Cow,
+    fs,
+    path::{Path, PathBuf},
+    str::FromStr as _,
+};
+
+use futures_util::{future::BoxFuture, FutureExt as _};
+use helix_core as core;
+use helix_core::Transaction;
+use helix_event::TaskHandle;
+use helix_stdx::path::{self, canonicalize, fold_home_dir, get_path_suffix};
+use helix_view::Document;
+use url::Url;
+
+use super::item::CompletionItem;
+
+pub(crate) fn path_completion(
+    cursor: usize,
+    text: core::Rope,
+    doc: &Document,
+    handle: TaskHandle,
+) -> Option<BoxFuture<'static, anyhow::Result<Vec<CompletionItem>>>> {
+    if !doc.path_completion_enabled() {
+        return None;
+    }
+
+    let cur_line = text.char_to_line(cursor);
+    let start = text.line_to_char(cur_line).max(cursor.saturating_sub(1000));
+    let line_until_cursor = text.slice(start..cursor);
+
+    let (dir_path, typed_file_name) =
+        get_path_suffix(line_until_cursor, false).and_then(|matched_path| {
+            let matched_path = Cow::from(matched_path);
+            let path: Cow<_> = if matched_path.starts_with("file://") {
+                Url::from_str(&matched_path)
+                    .ok()
+                    .and_then(|url| url.to_file_path().ok())?
+                    .into()
+            } else {
+                Path::new(&*matched_path).into()
+            };
+            let path = path::expand(&path);
+            let parent_dir = doc.path().and_then(|dp| dp.parent());
+            let path = match parent_dir {
+                Some(parent_dir) if path.is_relative() => parent_dir.join(&path),
+                _ => path.into_owned(),
+            };
+            #[cfg(windows)]
+            let ends_with_slash = matches!(matched_path.as_bytes().last(), Some(b'/' | b'\\'));
+            #[cfg(not(windows))]
+            let ends_with_slash = matches!(matched_path.as_bytes().last(), Some(b'/'));
+
+            if ends_with_slash {
+                Some((PathBuf::from(path.as_path()), None))
+            } else {
+                path.parent().map(|parent_path| {
+                    (
+                        PathBuf::from(parent_path),
+                        path.file_name().and_then(|f| f.to_str().map(String::from)),
+                    )
+                })
+            }
+        })?;
+
+    if handle.is_canceled() {
+        return None;
+    }
+
+    let future = tokio::task::spawn_blocking(move || {
+        let Ok(read_dir) = std::fs::read_dir(&dir_path) else {
+            return Vec::new();
+        };
+
+        read_dir
+            .filter_map(Result::ok)
+            .filter_map(|dir_entry| {
+                dir_entry
+                    .metadata()
+                    .ok()
+                    .and_then(|md| Some((dir_entry.file_name().into_string().ok()?, md)))
+            })
+            .map_while(|(file_name, md)| {
+                if handle.is_canceled() {
+                    return None;
+                }
+
+                let kind = path_kind(&md);
+                let documentation = path_documentation(&md, &dir_path.join(&file_name), kind);
+
+                let edit_diff = typed_file_name
+                    .as_ref()
+                    .map(|f| f.len())
+                    .unwrap_or_default();
+
+                let transaction = Transaction::change(
+                    &text,
+                    std::iter::once((cursor - edit_diff, cursor, Some((&file_name).into()))),
+                );
+
+                Some(CompletionItem::Other(core::CompletionItem {
+                    kind: Cow::Borrowed(kind),
+                    label: file_name.into(),
+                    transaction,
+                    documentation,
+                }))
+            })
+            .collect::<Vec<_>>()
+    });
+
+    Some(async move { Ok(future.await?) }.boxed())
+}
+
+#[cfg(unix)]
+fn path_documentation(md: &fs::Metadata, full_path: &Path, kind: &str) -> String {
+    let full_path = fold_home_dir(canonicalize(full_path));
+    let full_path_name = full_path.to_string_lossy();
+
+    use std::os::unix::prelude::PermissionsExt;
+    let mode = md.permissions().mode();
+
+    let perms = [
+        (libc::S_IRUSR, 'r'),
+        (libc::S_IWUSR, 'w'),
+        (libc::S_IXUSR, 'x'),
+        (libc::S_IRGRP, 'r'),
+        (libc::S_IWGRP, 'w'),
+        (libc::S_IXGRP, 'x'),
+        (libc::S_IROTH, 'r'),
+        (libc::S_IWOTH, 'w'),
+        (libc::S_IXOTH, 'x'),
+    ]
+    .into_iter()
+    .fold(String::with_capacity(9), |mut acc, (p, s)| {
+        // This cast is necessary on some platforms such as macos as `mode_t` is u16 there
+        #[allow(clippy::unnecessary_cast)]
+        acc.push(if mode & (p as u32) > 0 { s } else { '-' });
+        acc
+    });
+
+    // TODO it would be great to be able to individually color the documentation,
+    // but this will likely require a custom doc implementation (i.e. not `lsp::Documentation`)
+    // and/or different rendering in completion.rs
+    format!(
+        "type: `{kind}`\n\
+         permissions: `[{perms}]`\n\
+         full path: `{full_path_name}`",
+    )
+}
+
+#[cfg(not(unix))]
+fn path_documentation(md: &fs::Metadata, full_path: &Path, kind: &str) -> String {
+    let full_path = fold_home_dir(canonicalize(full_path));
+    let full_path_name = full_path.to_string_lossy();
+    format!("type: `{kind}`\nfull path: `{full_path_name}`",)
+}
+
+#[cfg(unix)]
+fn path_kind(md: &fs::Metadata) -> &'static str {
+    if md.is_symlink() {
+        "link"
+    } else if md.is_dir() {
+        "folder"
+    } else {
+        use std::os::unix::fs::FileTypeExt;
+        if md.file_type().is_block_device() {
+            "block"
+        } else if md.file_type().is_socket() {
+            "socket"
+        } else if md.file_type().is_char_device() {
+            "char_device"
+        } else if md.file_type().is_fifo() {
+            "fifo"
+        } else {
+            "file"
+        }
+    }
+}
+
+#[cfg(not(unix))]
+fn path_kind(md: &fs::Metadata) -> &'static str {
+    if md.is_symlink() {
+        "link"
+    } else if md.is_dir() {
+        "folder"
+    } else {
+        "file"
+    }
+}

helix-term/src/handlers/completion/resolve.rs

@@ -4,9 +4,10 @@ use helix_lsp::lsp;
 use tokio::sync::mpsc::Sender;
 use tokio::time::{Duration, Instant};
 
-use helix_event::{send_blocking, AsyncHook, CancelRx};
+use helix_event::{send_blocking, AsyncHook, TaskController, TaskHandle};
 use helix_view::Editor;
 
+use super::LspCompletionItem;
 use crate::handlers::completion::CompletionItem;
 use crate::job;
 
@@ -22,7 +23,7 @@ use crate::job;
 /// > 'completionItem/resolve' request is sent with the selected completion item as a parameter.
 /// > The returned completion item should have the documentation property filled in.
 pub struct ResolveHandler {
-    last_request: Option<Arc<CompletionItem>>,
+    last_request: Option<Arc<LspCompletionItem>>,
     resolver: Sender<ResolveRequest>,
 }
 
@@ -30,15 +31,11 @@ impl ResolveHandler {
     pub fn new() -> ResolveHandler {
         ResolveHandler {
             last_request: None,
-            resolver: ResolveTimeout {
-                next_request: None,
-                in_flight: None,
-            }
-            .spawn(),
+            resolver: ResolveTimeout::default().spawn(),
         }
     }
 
-    pub fn ensure_item_resolved(&mut self, editor: &mut Editor, item: &mut CompletionItem) {
+    pub fn ensure_item_resolved(&mut self, editor: &mut Editor, item: &mut LspCompletionItem) {
         if item.resolved {
             return;
         }
@@ -93,14 +90,15 @@ impl ResolveHandler {
 }
 
 struct ResolveRequest {
-    item: Arc<CompletionItem>,
+    item: Arc<LspCompletionItem>,
     ls: Arc<helix_lsp::Client>,
 }
 
 #[derive(Default)]
 struct ResolveTimeout {
     next_request: Option<ResolveRequest>,
-    in_flight: Option<(helix_event::CancelTx, Arc<CompletionItem>)>,
+    in_flight: Option<Arc<LspCompletionItem>>,
+    task_controller: TaskController,
 }
 
 impl AsyncHook for ResolveTimeout {
@@ -120,7 +118,7 @@ impl AsyncHook for ResolveTimeout {
         } else if self
             .in_flight
             .as_ref()
-            .is_some_and(|(_, old_request)| old_request.item == request.item.item)
+            .is_some_and(|old_request| old_request.item == request.item.item)
         {
             self.next_request = None;
             None
@@ -134,14 +132,14 @@ impl AsyncHook for ResolveTimeout {
         let Some(request) = self.next_request.take() else {
             return;
         };
-        let (tx, rx) = helix_event::cancelation();
-        self.in_flight = Some((tx, request.item.clone()));
-        tokio::spawn(request.execute(rx));
+        let token = self.task_controller.restart();
+        self.in_flight = Some(request.item.clone());
+        tokio::spawn(request.execute(token));
     }
 }
 
 impl ResolveRequest {
-    async fn execute(self, cancel: CancelRx) {
+    async fn execute(self, cancel: TaskHandle) {
         let future = self.ls.resolve_completion_item(&self.item.item);
         let Some(resolved_item) = helix_event::cancelable_future(future, cancel).await else {
             return;
@@ -152,8 +150,8 @@ impl ResolveRequest {
                 .unwrap()
                 .completion
             {
-                let resolved_item = match resolved_item {
-                    Ok(item) => CompletionItem {
+                let resolved_item = CompletionItem::Lsp(match resolved_item {
+                    Ok(item) => LspCompletionItem {
                         item,
                         resolved: true,
                         ..*self.item
@@ -166,8 +164,8 @@ impl ResolveRequest {
                         item.resolved = true;
                         item
                     }
-                };
-                completion.replace_item(&self.item, resolved_item);
+                });
+                completion.replace_item(&*self.item, resolved_item);
             };
         })
         .await

helix-term/src/handlers/signature_help.rs

@@ -2,9 +2,7 @@ use std::sync::Arc;
 use std::time::Duration;
 
 use helix_core::syntax::LanguageServerFeature;
-use helix_event::{
-    cancelable_future, cancelation, register_hook, send_blocking, CancelRx, CancelTx,
-};
+use helix_event::{cancelable_future, register_hook, send_blocking, TaskController, TaskHandle};
 use helix_lsp::lsp::{self, SignatureInformation};
 use helix_stdx::rope::RopeSliceExt;
 use helix_view::document::Mode;
@@ -22,11 +20,11 @@ use crate::ui::lsp::{Signature, SignatureHelp};
 use crate::ui::Popup;
 use crate::{job, ui};
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Eq)]
 enum State {
     Open,
     Closed,
-    Pending { request: CancelTx },
+    Pending,
 }
 
 /// debounce timeout in ms, value taken from VSCode
@@ -37,6 +35,7 @@ const TIMEOUT: u64 = 120;
 pub(super) struct SignatureHelpHandler {
     trigger: Option<SignatureHelpInvoked>,
     state: State,
+    task_controller: TaskController,
 }
 
 impl SignatureHelpHandler {
@@ -44,6 +43,7 @@ impl SignatureHelpHandler {
         SignatureHelpHandler {
             trigger: None,
             state: State::Closed,
+            task_controller: TaskController::new(),
         }
     }
 }
@@ -76,12 +76,11 @@ impl helix_event::AsyncHook for SignatureHelpHandler {
             }
             SignatureHelpEvent::RequestComplete { open } => {
                 // don't cancel rerequest that was already triggered
-                if let State::Pending { request } = &self.state {
-                    if !request.is_closed() {
+                if self.state == State::Pending && self.task_controller.is_running() {
                     return timeout;
                 }
-                }
                 self.state = if open { State::Open } else { State::Closed };
+                self.task_controller.cancel();
 
                 return timeout;
             }
@@ -94,16 +93,16 @@ impl helix_event::AsyncHook for SignatureHelpHandler {
 
     fn finish_debounce(&mut self) {
         let invocation = self.trigger.take().unwrap();
-        let (tx, rx) = cancelation();
-        self.state = State::Pending { request: tx };
-        job::dispatch_blocking(move |editor, _| request_signature_help(editor, invocation, rx))
+        self.state = State::Pending;
+        let handle = self.task_controller.restart();
+        job::dispatch_blocking(move |editor, _| request_signature_help(editor, invocation, handle))
     }
 }
 
 pub fn request_signature_help(
     editor: &mut Editor,
     invoked: SignatureHelpInvoked,
-    cancel: CancelRx,
+    cancel: TaskHandle,
 ) {
     let (view, doc) = current!(editor);
 

helix-term/src/ui/completion.rs

@@ -1,6 +1,9 @@
 use crate::{
     compositor::{Component, Context, Event, EventResult},
-    handlers::{completion::ResolveHandler, trigger_auto_completion},
+    handlers::{
+        completion::{CompletionItem, LspCompletionItem, ResolveHandler},
+        trigger_auto_completion,
+    },
 };
 use helix_view::{
     document::SavePoint,
@@ -13,12 +16,12 @@ use tui::{buffer::Buffer as Surface, text::Span};
 
 use std::{borrow::Cow, sync::Arc};
 
-use helix_core::{chars, Change, Transaction};
+use helix_core::{self as core, chars, Change, Transaction};
 use helix_view::{graphics::Rect, Document, Editor};
 
 use crate::ui::{menu, Markdown, Menu, Popup, PromptEvent};
 
-use helix_lsp::{lsp, util, LanguageServerId, OffsetEncoding};
+use helix_lsp::{lsp, util, OffsetEncoding};
 
 impl menu::Item for CompletionItem {
     type Data = ();
@@ -28,30 +31,35 @@ impl menu::Item for CompletionItem {
 
     #[inline]
     fn filter_text(&self, _data: &Self::Data) -> Cow<str> {
-        self.item
+        match self {
+            CompletionItem::Lsp(LspCompletionItem { item, .. }) => item
                 .filter_text
                 .as_ref()
-            .unwrap_or(&self.item.label)
+                .unwrap_or(&item.label)
                 .as_str()
-            .into()
+                .into(),
+            CompletionItem::Other(core::CompletionItem { label, .. }) => label.clone(),
+        }
     }
 
     fn format(&self, _data: &Self::Data) -> menu::Row {
-        let deprecated = self.item.deprecated.unwrap_or_default()
-            || self.item.tags.as_ref().map_or(false, |tags| {
+        let deprecated = match self {
+            CompletionItem::Lsp(LspCompletionItem { item, .. }) => {
+                item.deprecated.unwrap_or_default()
+                    || item.tags.as_ref().map_or(false, |tags| {
                         tags.contains(&lsp::CompletionItemTag::DEPRECATED)
-            });
+                    })
+            }
+            CompletionItem::Other(_) => false,
+        };
 
-        menu::Row::new(vec![
-            menu::Cell::from(Span::styled(
-                self.item.label.as_str(),
-                if deprecated {
-                    Style::default().add_modifier(Modifier::CROSSED_OUT)
-                } else {
-                    Style::default()
-                },
-            )),
-            menu::Cell::from(match self.item.kind {
+        let label = match self {
+            CompletionItem::Lsp(LspCompletionItem { item, .. }) => item.label.as_str(),
+            CompletionItem::Other(core::CompletionItem { label, .. }) => label,
+        };
+
+        let kind = match self {
+            CompletionItem::Lsp(LspCompletionItem { item, .. }) => match item.kind {
                 Some(lsp::CompletionItemKind::TEXT) => "text",
                 Some(lsp::CompletionItemKind::METHOD) => "method",
                 Some(lsp::CompletionItemKind::FUNCTION) => "function",
@@ -82,18 +90,24 @@ impl menu::Item for CompletionItem {
                     ""
                 }
                 None => "",
-            }),
+            },
+            CompletionItem::Other(core::CompletionItem { kind, .. }) => kind,
+        };
+
+        menu::Row::new([
+            menu::Cell::from(Span::styled(
+                label,
+                if deprecated {
+                    Style::default().add_modifier(Modifier::CROSSED_OUT)
+                } else {
+                    Style::default()
+                },
+            )),
+            menu::Cell::from(kind),
         ])
     }
 }
 
-#[derive(Debug, PartialEq, Default, Clone)]
-pub struct CompletionItem {
-    pub item: lsp::CompletionItem,
-    pub provider: LanguageServerId,
-    pub resolved: bool,
-}
-
 /// Wraps a Menu.
 pub struct Completion {
     popup: Popup<Menu<CompletionItem>>,
@@ -115,11 +129,11 @@ impl Completion {
         let preview_completion_insert = editor.config().preview_completion_insert;
         let replace_mode = editor.config().completion_replace;
         // Sort completion items according to their preselect status (given by the LSP server)
-        items.sort_by_key(|item| !item.item.preselect.unwrap_or(false));
+        items.sort_by_key(|item| !item.preselect());
 
         // Then create the menu
         let menu = Menu::new(items, (), move |editor: &mut Editor, item, event| {
-            fn item_to_transaction(
+            fn lsp_item_to_transaction(
                 doc: &Document,
                 view_id: ViewId,
                 item: &lsp::CompletionItem,
@@ -257,7 +271,9 @@ impl Completion {
                     // always present here
                     let item = item.unwrap();
 
-                    let transaction = item_to_transaction(
+                    match item {
+                        CompletionItem::Lsp(item) => doc.apply_temporary(
+                            &lsp_item_to_transaction(
                                 doc,
                                 view.id,
                                 &item.item,
@@ -265,8 +281,13 @@ impl Completion {
                                 trigger_offset,
                                 true,
                                 replace_mode,
-                    );
-                    doc.apply_temporary(&transaction, view.id);
+                            ),
+                            view.id,
+                        ),
+                        CompletionItem::Other(core::CompletionItem { transaction, .. }) => {
+                            doc.apply_temporary(transaction, view.id)
+                        }
+                    };
                 }
                 PromptEvent::Update => {}
                 PromptEvent::Validate => {
@@ -275,32 +296,46 @@ impl Completion {
                     {
                         doc.restore(view, &savepoint, false);
                     }
-                    // always present here
-                    let mut item = item.unwrap().clone();
 
+                    // if more text was entered, remove it
+                    doc.restore(view, &savepoint, true);
+                    // save an undo checkpoint before the completion
+                    doc.append_changes_to_history(view);
+
+                    // item always present here
+                    let (transaction, additional_edits) = match item.unwrap().clone() {
+                        CompletionItem::Lsp(mut item) => {
                             let language_server = language_server!(item);
-                    let offset_encoding = language_server.offset_encoding();
 
+                            // resolve item if not yet resolved
                             if !item.resolved {
-                        if let Some(resolved) =
-                            Self::resolve_completion_item(language_server, item.item.clone())
-                        {
-                            item.item = resolved;
+                                if let Some(resolved_item) = Self::resolve_completion_item(
+                                    language_server,
+                                    item.item.clone(),
+                                ) {
+                                    item.item = resolved_item;
                                 }
                             };
-                    // if more text was entered, remove it
-                    doc.restore(view, &savepoint, true);
-                    // save an undo checkpoint before the completion
-                    doc.append_changes_to_history(view);
-                    let transaction = item_to_transaction(
+
+                            let encoding = language_server.offset_encoding();
+                            let transaction = lsp_item_to_transaction(
                                 doc,
                                 view.id,
                                 &item.item,
-                        offset_encoding,
+                                encoding,
                                 trigger_offset,
                                 false,
                                 replace_mode,
                             );
+                            let add_edits = item.item.additional_text_edits;
+
+                            (transaction, add_edits.map(|edits| (edits, encoding)))
+                        }
+                        CompletionItem::Other(core::CompletionItem { transaction, .. }) => {
+                            (transaction, None)
+                        }
+                    };
+
                     doc.apply(&transaction, view.id);
 
                     editor.last_completion = Some(CompleteAction::Applied {
@@ -309,7 +344,7 @@ impl Completion {
                     });
 
                     // TODO: add additional _edits to completion_changes?
-                    if let Some(additional_edits) = item.item.additional_text_edits {
+                    if let Some((additional_edits, offset_encoding)) = additional_edits {
                         if !additional_edits.is_empty() {
                             let transaction = util::generate_transaction_from_edits(
                                 doc.text(),
@@ -414,7 +449,11 @@ impl Completion {
         self.popup.contents().is_empty()
     }
 
-    pub fn replace_item(&mut self, old_item: &CompletionItem, new_item: CompletionItem) {
+    pub fn replace_item(
+        &mut self,
+        old_item: &impl PartialEq<CompletionItem>,
+        new_item: CompletionItem,
+    ) {
         self.popup.contents_mut().replace_option(old_item, new_item);
     }
 
@@ -440,7 +479,7 @@ impl Component for Completion {
             Some(option) => option,
             None => return,
         };
-        if !option.resolved {
+        if let CompletionItem::Lsp(option) = option {
             self.resolve_handler.ensure_item_resolved(cx.editor, option);
         }
         // need to render:
@@ -465,7 +504,8 @@ impl Component for Completion {
             Markdown::new(md, cx.editor.syn_loader.clone())
         };
 
-        let mut markdown_doc = match &option.item.documentation {
+        let mut markdown_doc = match option {
+            CompletionItem::Lsp(option) => match &option.item.documentation {
                 Some(lsp::Documentation::String(contents))
                 | Some(lsp::Documentation::MarkupContent(lsp::MarkupContent {
                     kind: lsp::MarkupKind::PlainText,
@@ -486,6 +526,10 @@ impl Component for Completion {
                     markdowned(language, option.item.detail.as_deref(), None)
                 }
                 None => return,
+            },
+            CompletionItem::Other(option) => {
+                markdowned(language, None, Some(&option.documentation))
+            }
         };
 
         let popup_area = self.popup.area(area, cx.editor);

helix-term/src/ui/editor.rs

@@ -2,13 +2,14 @@ use crate::{
     commands::{self, OnKeyCallback},
     compositor::{Component, Context, Event, EventResult},
     events::{OnModeSwitch, PostCommand},
+    handlers::completion::CompletionItem,
     key,
     keymap::{KeymapResult, Keymaps},
     ui::{
         document::{render_document, LinePos, TextRenderer},
         statusline,
         text_decorations::{self, Decoration, DecorationManager, InlineDiagnostics},
-        Completion, CompletionItem, ProgressSpinners,
+        Completion, ProgressSpinners,
     },
 };
 

helix-term/src/ui/menu.rs

@@ -228,7 +228,7 @@ impl<T: Item> Menu<T> {
 }
 
 impl<T: Item + PartialEq> Menu<T> {
-    pub fn replace_option(&mut self, old_option: &T, new_option: T) {
+    pub fn replace_option(&mut self, old_option: &impl PartialEq<T>, new_option: T) {
         for option in &mut self.options {
             if old_option == option {
                 *option = new_option;

helix-term/src/ui/mod.rs

@@ -17,7 +17,7 @@ mod text_decorations;
 use crate::compositor::Compositor;
 use crate::filter_picker_entry;
 use crate::job::{self, Callback};
-pub use completion::{Completion, CompletionItem};
+pub use completion::Completion;
 pub use editor::EditorView;
 use helix_stdx::rope;
 pub use markdown::Markdown;

helix-view/src/document.rs

@@ -1713,6 +1713,12 @@ impl Document {
         self.version
     }
 
+    pub fn path_completion_enabled(&self) -> bool {
+        self.language_config()
+            .and_then(|lang_config| lang_config.path_completion)
+            .unwrap_or_else(|| self.config.load().path_completion)
+    }
+
     /// maintains the order as configured in the language_servers TOML array
     pub fn language_servers(&self) -> impl Iterator<Item = &helix_lsp::Client> {
         self.language_config().into_iter().flat_map(move |config| {

helix-view/src/editor.rs

@@ -268,6 +268,11 @@ pub struct Config {
     pub auto_pairs: AutoPairConfig,
     /// Automatic auto-completion, automatically pop up without user trigger. Defaults to true.
     pub auto_completion: bool,
+    /// Enable filepath completion.
+    /// Show files and directories if an existing path at the cursor was recognized,
+    /// either absolute or relative to the current opened document or current working directory (if the buffer is not yet saved).
+    /// Defaults to true.
+    pub path_completion: bool,
     /// Automatic formatting on save. Defaults to true.
     pub auto_format: bool,
     /// Default register used for yank/paste. Defaults to '"'
@@ -952,6 +957,7 @@ impl Default for Config {
             middle_click_paste: true,
             auto_pairs: AutoPairConfig::default(),
             auto_completion: true,
+            path_completion: true,
             auto_format: true,
             default_yank_register: '"',
             auto_save: AutoSave::default(),