make path changes LSP spec conform

Currently, helix implements operations which change the paths of files
incorrectly and inconsistently. This PR ensures that we do the following
whenever a buffer is renamed (`:move` and workspace edits)

* always send did_open/did_close notifications
* send will_rename/did_rename requests correctly
  * send them to all LSP servers not just those that are active for a
    buffer
  * also send these requests for paths that are not yet open in a buffer (if
    triggered from workspace edit).
  * only send these if the server registered interests in the path
* autodetect language, indent, line ending, ..

This PR also centralizes the infrastructure for path setting and
therefore `:w <path>` benefits from similar fixed (but without didRename)

helix-lsp/src/client.rs

@@ -1,4 +1,5 @@
 use crate::{
+    file_operations::FileOperationsInterest,
     find_lsp_workspace, jsonrpc,
     transport::{Payload, Transport},
     Call, Error, OffsetEncoding, Result,
@@ -8,20 +9,20 @@ use helix_core::{find_workspace, path, syntax::LanguageServerFeature, ChangeSet,
 use helix_loader::{self, VERSION_AND_GIT_HASH};
 use lsp::{
     notification::DidChangeWorkspaceFolders, CodeActionCapabilityResolveSupport,
-    DidChangeWorkspaceFoldersParams, OneOf, PositionEncodingKind, WorkspaceFolder,
+    DidChangeWorkspaceFoldersParams, OneOf, PositionEncodingKind, Url, WorkspaceFolder,
     WorkspaceFoldersChangeEvent,
 };
 use lsp_types as lsp;
 use parking_lot::Mutex;
 use serde::Deserialize;
 use serde_json::Value;
-use std::future::Future;
-use std::process::Stdio;
 use std::sync::{
     atomic::{AtomicU64, Ordering},
     Arc,
 };
 use std::{collections::HashMap, path::PathBuf};
+use std::{future::Future, sync::OnceLock};
+use std::{path::Path, process::Stdio};
 use tokio::{
     io::{BufReader, BufWriter},
     process::{Child, Command},
@@ -50,6 +51,7 @@ pub struct Client {
     server_tx: UnboundedSender<Payload>,
     request_counter: AtomicU64,
     pub(crate) capabilities: OnceCell<lsp::ServerCapabilities>,
+    pub(crate) file_operation_interest: OnceLock<FileOperationsInterest>,
     config: Option<Value>,
     root_path: std::path::PathBuf,
     root_uri: Option<lsp::Url>,
@@ -232,6 +234,7 @@ impl Client {
             server_tx,
             request_counter: AtomicU64::new(0),
             capabilities: OnceCell::new(),
+            file_operation_interest: OnceLock::new(),
             config,
             req_timeout,
             root_path,
@@ -277,6 +280,11 @@ impl Client {
             .expect("language server not yet initialized!")
     }
 
+    pub(crate) fn file_operations_intests(&self) -> &FileOperationsInterest {
+        self.file_operation_interest
+            .get_or_init(|| FileOperationsInterest::new(self.capabilities()))
+    }
+
     /// Client has to be initialized otherwise this function panics
     #[inline]
     pub fn supports_feature(&self, feature: LanguageServerFeature) -> bool {
@@ -715,27 +723,27 @@ impl Client {
         })
     }
 
-    pub fn prepare_file_rename(
+    pub fn will_rename(
         &self,
-        old_uri: &lsp::Url,
-        new_uri: &lsp::Url,
+        old_path: &Path,
+        new_path: &Path,
+        is_dir: bool,
     ) -> Option<impl Future<Output = Result<lsp::WorkspaceEdit>>> {
-        let capabilities = self.capabilities.get().unwrap();
-
-        // Return early if the server does not support willRename feature
-        match &capabilities.workspace {
-            Some(workspace) => match &workspace.file_operations {
-                Some(op) => {
-                    op.will_rename.as_ref()?;
-                }
-                _ => return None,
-            },
-            _ => return None,
+        let capabilities = self.file_operations_intests();
+        if !capabilities.will_rename.has_interest(old_path, is_dir) {
+            return None;
         }
-
+        let url_from_path = |path| {
+            let url = if is_dir {
+                Url::from_directory_path(path)
+            } else {
+                Url::from_file_path(path)
+            };
+            Some(url.ok()?.to_string())
+        };
         let files = vec![lsp::FileRename {
-            old_uri: old_uri.to_string(),
-            new_uri: new_uri.to_string(),
+            old_uri: url_from_path(old_path)?,
+            new_uri: url_from_path(new_path)?,
         }];
         let request = self.call_with_timeout::<lsp::request::WillRenameFiles>(
             lsp::RenameFilesParams { files },
@@ -749,27 +757,28 @@ impl Client {
         })
     }
 
-    pub fn did_file_rename(
+    pub fn did_rename(
         &self,
-        old_uri: &lsp::Url,
-        new_uri: &lsp::Url,
+        old_path: &Path,
+        new_path: &Path,
+        is_dir: bool,
     ) -> Option<impl Future<Output = std::result::Result<(), Error>>> {
-        let capabilities = self.capabilities.get().unwrap();
-
-        // Return early if the server does not support DidRename feature
-        match &capabilities.workspace {
-            Some(workspace) => match &workspace.file_operations {
-                Some(op) => {
-                    op.did_rename.as_ref()?;
-                }
-                _ => return None,
-            },
-            _ => return None,
+        let capabilities = self.file_operations_intests();
+        if !capabilities.did_rename.has_interest(new_path, is_dir) {
+            return None;
         }
+        let url_from_path = |path| {
+            let url = if is_dir {
+                Url::from_directory_path(path)
+            } else {
+                Url::from_file_path(path)
+            };
+            Some(url.ok()?.to_string())
+        };
 
         let files = vec![lsp::FileRename {
-            old_uri: old_uri.to_string(),
-            new_uri: new_uri.to_string(),
+            old_uri: url_from_path(old_path)?,
+            new_uri: url_from_path(new_path)?,
         }];
         Some(self.notify::<lsp::notification::DidRenameFiles>(lsp::RenameFilesParams { files }))
     }

helix-lsp/src/file_operations.rs

@@ -0,0 +1,105 @@
+use std::path::Path;
+
+use globset::{GlobBuilder, GlobSet};
+
+use crate::lsp;
+
+#[derive(Default, Debug)]
+pub(crate) struct FileOperationFilter {
+    dir_globs: GlobSet,
+    file_globs: GlobSet,
+}
+
+impl FileOperationFilter {
+    fn new(capability: Option<&lsp::FileOperationRegistrationOptions>) -> FileOperationFilter {
+        let Some(cap) = capability else {
+            return FileOperationFilter::default();
+        };
+        let mut dir_globs = GlobSet::builder();
+        let mut file_globs = GlobSet::builder();
+        for filter in &cap.filters {
+            // TODO: support other url schemes
+            let is_non_file_schema = filter
+                .scheme
+                .as_ref()
+                .is_some_and(|schema| schema != "file");
+            if is_non_file_schema {
+                continue;
+            }
+            let ignore_case = filter
+                .pattern
+                .options
+                .as_ref()
+                .and_then(|opts| opts.ignore_case)
+                .unwrap_or(false);
+            let mut glob_builder = GlobBuilder::new(&filter.pattern.glob);
+            glob_builder.case_insensitive(!ignore_case);
+            let glob = match glob_builder.build() {
+                Ok(glob) => glob,
+                Err(err) => {
+                    log::error!("invalid glob send by LS: {err}");
+                    continue;
+                }
+            };
+            match filter.pattern.matches {
+                Some(lsp::FileOperationPatternKind::File) => {
+                    file_globs.add(glob);
+                }
+                Some(lsp::FileOperationPatternKind::Folder) => {
+                    dir_globs.add(glob);
+                }
+                None => {
+                    file_globs.add(glob.clone());
+                    dir_globs.add(glob);
+                }
+            };
+        }
+        let file_globs = file_globs.build().unwrap_or_else(|err| {
+            log::error!("invalid globs send by LS: {err}");
+            GlobSet::empty()
+        });
+        let dir_globs = dir_globs.build().unwrap_or_else(|err| {
+            log::error!("invalid globs send by LS: {err}");
+            GlobSet::empty()
+        });
+        FileOperationFilter {
+            dir_globs,
+            file_globs,
+        }
+    }
+
+    pub(crate) fn has_interest(&self, path: &Path, is_dir: bool) -> bool {
+        if is_dir {
+            self.dir_globs.is_match(path)
+        } else {
+            self.file_globs.is_match(path)
+        }
+    }
+}
+
+#[derive(Default, Debug)]
+pub(crate) struct FileOperationsInterest {
+    // TODO: support other notifications
+    // did_create: FileOperationFilter,
+    // will_create: FileOperationFilter,
+    pub did_rename: FileOperationFilter,
+    pub will_rename: FileOperationFilter,
+    // did_delete: FileOperationFilter,
+    // will_delete: FileOperationFilter,
+}
+
+impl FileOperationsInterest {
+    pub fn new(capabilities: &lsp::ServerCapabilities) -> FileOperationsInterest {
+        let capabilities = capabilities
+            .workspace
+            .as_ref()
+            .and_then(|capabilities| capabilities.file_operations.as_ref());
+        let Some(capabilities) = capabilities else {
+            return FileOperationsInterest::default();
+        };
+        FileOperationsInterest {
+            did_rename: FileOperationFilter::new(capabilities.did_rename.as_ref()),
+            will_rename: FileOperationFilter::new(capabilities.will_rename.as_ref()),
+        }
+    }
+}

helix-lsp/src/lib.rs

@@ -1,5 +1,6 @@
 mod client;
 pub mod file_event;
+mod file_operations;
 pub mod jsonrpc;
 pub mod snippet;
 mod transport;

helix-term/src/application.rs

@@ -24,7 +24,6 @@ use tui::backend::Backend;
 
 use crate::{
     args::Args,
-    commands::apply_workspace_edit,
     compositor::{Compositor, Event},
     config::Config,
     job::Jobs,
@@ -556,18 +555,8 @@ impl Application {
         let lines = doc_save_event.text.len_lines();
         let bytes = doc_save_event.text.len_bytes();
 
-        if doc.path() != Some(&doc_save_event.path) {
-            doc.set_path(Some(&doc_save_event.path));
-
-            let loader = self.editor.syn_loader.clone();
-
-            // borrowing the same doc again to get around the borrow checker
-            let doc = doc_mut!(self.editor, &doc_save_event.doc_id);
-            let id = doc.id();
-            doc.detect_language(loader);
-            self.editor.refresh_language_servers(id);
-        }
-
+        self.editor
+            .set_doc_path(doc_save_event.doc_id, &doc_save_event.path);
         // TODO: fix being overwritten by lsp
         self.editor.set_status(format!(
             "'{}' written, {}L {}B",
@@ -1029,11 +1018,9 @@ impl Application {
                         let language_server = language_server!();
                         if language_server.is_initialized() {
                             let offset_encoding = language_server.offset_encoding();
-                            let res = apply_workspace_edit(
-                                &mut self.editor,
-                                offset_encoding,
-                                &params.edit,
-                            );
+                            let res = self
+                                .editor
+                                .apply_workspace_edit(offset_encoding, &params.edit);
 
                             Ok(json!(lsp::ApplyWorkspaceEditResponse {
                                 applied: res.is_ok(),