Eglot does not rename files

[witek]

When performing eglot-rename the rename can require renaming files.

Example: Renaming a Clojure namespace (which would be a "module name", a "package name" or a "class name" in other languages) means that the file in which the namespace is delcared has to be renamed or even moved to another directory. Here is the log of renaming the namespace foo which is in file foo.clj to a.bar which should be moved to a/bar.clj:

[client-request] (id:113) Wed Sep 28 11:30:25 2022:
(:jsonrpc "2.0" :id 113 :method "textDocument/rename" :params
          (:textDocument
           (:uri "file:///p/clj/src/foo.clj")
           :position
           (:line 0 :character 4)
           :newName "a.bar"))
[server-reply] (id:113) Wed Sep 28 11:30:25 2022:
(:jsonrpc "2.0" :id 113 :result
          (:documentChanges
           [(:textDocument
             (:version 0 :uri "file:///p/clj/src/foo.clj")
             :edits
             [(:range
               (:start
                (:line 0 :character 4)
                :end
                (:line 0 :character 7))
               :newText "a.bar")])
            (:kind "rename" :oldUri "file:///p/clj/src/foo.clj" :newUri "file:///p/clj/src/a/bar.clj")]))

It seams, the LSP server sends the required "rename" but Eglot is not executing it.

[joaotavora]

Eglot doesn't support this, which is in version 3.16 of the LSP protocol. I'm not sure the Clojure LSP server is correctly checking for this capability, which is absent from Eglot at the moment. If you or someone would like to implement this, that is a welcome change request.

It seems the function to touch is eglot--apply-workspace-edit. The Emacs primitive to rename files is rename-file.

I do NOT have a server to test this, so someone with a ClojureLSP or similar server will have to do this implementation.

[joaotavora]

More info: the relevant section of the spec is: https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#workspaceEdit

Once this is done, Eglot will support the workspace.workspaceEdit.resourceOperations or some variation thereof. The protocol seems messy in this area, so be careful. Also note workspace.workspaceEdit.failureHandling

[witek]

If you or someone would like to implement this, that is a welcome change request.

I am trying hard. But I am new to Emacs lisp and I have problems with eglot--aply-workspace-edit. It seams to expect only documentChanges in form of (:textDocument (:uri "..." ...)). But servers also send elements in this form: (:kind "rename" :oldUri "..." :newUri "").

This already causes a bug, because (cl-notevery #'find-buffer-visiting (mapcar #'car prepared)) returns true for documentChanges with unexpected forms. This is because prepared is (nil nil) and find-buffer-visiting is called with nil.

So my approach would be:

1. Change the prepared list so that the first element is not the uri, but a keyword describing the type of the change. Like :edit and :rename.
2. Update the code around y-or-n-p to use the second element in prepared (which now would be the uri).
3. Update the code in cl-loop to have a case/switch on the new keyword in prepared and move current code into the switch/case for :edit.

After this we should have refactored the code without breaking things.

4. Add the new code as a switch/case for :rename.

Another idea would be to fill the prepared list with (uri exec-function) where exec-function would be a function which is called inside of cl-loop.

What do you think?

[joaotavora]

What do you think?

Great start!

This already causes a bug, because (cl-notevery #'find-buffer-visiting (mapcar #'car prepared)) returns true for documentChanges with unexpected forms. This is because prepared is (nil nil) and find-buffer-visiting is called with nil.

Yes, but technically this bug is not on Eglot's side. As I explained, Clojure LSP is not checking beforehand if Eglot supports these heterogenous collection before sending such a collection.

So do what you think is correct to that function, including refactoring it, so that the current use-case is honoured and the new use cases are also honoured. Then publish that as a patch/diff/PR and I'll have a look and we'll iterate. You'll be running the tests, since I don't have the clojure-lsp server.

If you prefer, you can also write an automated test based on the clojure-lsp server. That would help things. But if you're not very proficient with Elisp, I suggest you don't worry about that now.

[jgarte]

This feature also does not currently work for jedi-language-server which I've tested.

See the following for some more context: pappasam/jedi-language-server#209

[timcharper]

Overlapping concern but unlikely the same. It seems here a refactor request performs renames client side?

I wanted rename-file support (explicitly rename files in typescript) and have a terrible but working solution here:

#1396

[yveszoundi]

I had a similar ask in eglot-java, as renaming a top-level Java class name should also result into renaming the associated file.

• The relevant pull request was "working" after minimal testing, but restricted to eglot-java: [RFC Don't merge] rename: Initial fix to type renaming yveszoundi/eglot-java#42
• The goal was to bring that functionality into eglot itself (handle create/rename/delete resource operations): https://lists.gnu.org/archive/html/emacs-devel/2024-03/msg00157.html

@lina-bh , did you make progress with eglot core integration thus far or would it be better for someone else to help move it forward?

[lina-bh]

Unfortunately my university says they don't know what to do with the copyright waiver FSF sent me, and I stopped writing Java for now so I've kind of lost interest. I have made a start on an extension package which advises Eglot functions to implement resource operation support, I can share that.

[lina-bh]

The essential design of the extension package I am writing is:

1. Add the resource operation types to eglot--lsp-interface-list.
2. Make eglot-client-capabilities send:

(:workspace
 (:workspaceEdit
  (:documentChanges
   t
   :resourceOperations
   ["create" "delete" "rename"])))

3. Change eglot--apply-workspace-edit to separate resource operations and TextDocumentEdit by the presence of 'edit. I used seq-group-by for this.
4. Make eglot--apply-workspace-edit always prompt when the server requests resource operations.
5. Dispatch based on type. I'm not sure which order the operations should be applied, either the order in which they appear in documentChanges or ordering by type. I would be thinking of using rename-visited-file for renames unless it needs to be changed to be compatible with old Emacsen.

Like I said in the other comment, my university basically threw up their hands and said "We don't know what to do with this" when I chased them up for a copyright waiver, so I don't think I'd be able to get this into Emacs git for a while, but I can throw it up on a gist if anyone wants me to.