eglot codeAction could add a context key

[Andre0991]

Hi.

It seems that eglot does not send context in codeAction requests. This prevent the server from responding with codeActions that are available for the same line when the point is not necessarily over some diagnostics.

According to the spec,

export interface CodeActionContext {
	/**
	 * An array of diagnostics known on the client side overlapping the range
	 * provided to the `textDocument/codeAction` request. They are provided so
	 * that the server knows which errors are currently presented to the user
	 * for the given range. There is no guarantee that these accurately reflect
	 * the error state of the resource. The primary parameter
	 * to compute code actions is the provided range.
	 */

For example, consider this sample clojure file:

(ns foo)

(str/foo) bar

Suppose the point is in the last position of the last line, just after bar.

Then, eglot sends this codeAction request:

(:jsonrpc "2.0" :id 11 :method "textDocument/codeAction" :params
	  (:textDocument
	   (:uri "file:///Users/andreperictavares/dev/nu/isa-bff/src/isa_bff/controllers/service/foo.clj")
	   :range
	   (:start
	    (:line 2 :character 12)
	    :end
	    (:line 2 :character 12))
	   :context
	   (:diagnostics
	    [])))

and this is the server reply, containing only one action:

(:jsonrpc "2.0" :id 11 :result
	  [(:title "Clean namespace" :kind "source.organizeImports" :command
		   (:title "Clean namespace" :command "clean-ns" :arguments
			   ["file:///Users/andreperictavares/dev/nu/isa-bff/src/isa_bff/controllers/service/foo.clj" 2 12]))])

Now, if eglot sent context, it would return more code actions.

For example, this is a sample from lsp-mode, with the same file:

{
  "textDocument": {
    "uri": "file:///Users/andreperictavares/dev/nu/isa-bff/src/isa_bff/controllers/service/foo.clj"
  },
  "range": {
    "start": {
      "line": 2,
      "character": 12
    },
    "end": {
      "line": 2,
      "character": 12
    }
  },
  "context": {
    "diagnostics": [
      {
        "range": {
          "start": {
            "line": 2,
            "character": 1
          },
          "end": {
            "line": 2,
            "character": 8
          }
        },
        "severity": 2,
        "code": "unresolved-namespace",
        "source": "clj-kondo",
        "message": "Unresolved namespace str. Are you missing a require?",
        "tags": []
      }
    ]
  }
}

and the result contains many actions (I'll omit it here because it's too big, it's suggesting lots of imports whose name could be str).

---

I think the most annoying situation that I miss without context is not being able to use an import code action when the point is just after part of a symbol.

For example, say the line is

(str/starts-with|)

where | is the point. It would like to use eglot-code-actions for importing str as [clojure.string :as str] just after pressing h. However, I need to move backward one char, moving the point above the missing import diagnostic. Only then eglot displays the code action that I need.

[joaotavora]

As far as I can read from the code, yes Eglot sends context, of course it does.

(jsonrpc-request
           server
           :textDocument/codeAction
           (list :textDocument (eglot--TextDocumentIdentifier)
                 :range (list :start (eglot--pos-to-lsp-position beg)
                              :end (eglot--pos-to-lsp-position end))
                 :context
                 `(:diagnostics
                   [,@(cl-loop for diag in (flymake-diagnostics beg end)
                               when (cdr (assoc 'eglot-lsp-diag
                                                (eglot--diag-data diag)))
                               collect it)]
                   ,@(when action-kind `(:only [,action-kind]))))
           :deferred t)

The "context" that the lsp-mode is giving does contain a diagnostic. Is at least that diagnostic in the Eglot version as well? There's no way to tell from the information you gave us.

Anyway, if it is then it is possible to transmit it to the server, but that depends how you invoke eglot-code-actions. How did you do it? Did you M-x eglot-code-actions with a region selected or just a specific point?

Reading your log, it seems the latter. It seems that lsp-mode liberally expands the context collection range to the span at least the whole line after being asked to provide code actions on a point. We could do that (assuming it's LSP-kosher) but I would like to know what happens in your example if you select the whole line and then M-x eglot-code-actions.

[Andre0991]

The range for the whole line I think is too large, and too arbitrary (especially for lisps, right? ;-) ) But the range for the current "thing at point" makes sense to me.

Fair point.

With the patch, when asking for code actions with the point just after the symbol (as in (set/union|), where | is the point), I get this error:

byte-code: Wrong type argument: listp, 25462

Using debug on error:

Debugger entered--Lisp error: (wrong-type-argument listp 25462)
  append((25455 . 25462) (nil))
  byte-code("\301\302 \10\205\13\0\303\304\305\"C\"\207" [current-prefix-arg append eglot--region-bounds completing-read "[eglot] Action kind: " ("quickfix" "refactor.extract" "refactor.inline" "refactor.rewrite" "source.organizeImports")] 5)
  command-execute(eglot-code-actions)

[joaotavora]

Sorry about that, the usual Lisp brainfart here. Try this one:

diff --git a/eglot.el b/eglot.el
index ea9299a..29722b2 100644
--- a/eglot.el
+++ b/eglot.el
@@ -2821,8 +2821,11 @@ is not active."
                                            :newName ,newname))
    current-prefix-arg))
 
-(defun eglot--region-bounds () "Region bounds if active, else point and nil."
-  (if (use-region-p) `(,(region-beginning) ,(region-end)) `(,(point) nil)))
+(defun eglot--region-bounds ()
+  "Region bounds if active, else bounds of things at point."
+  (if (use-region-p) `(,(region-beginning) ,(region-end))
+    (let ((botap (bounds-of-thing-at-point 'sexp)))
+      (list (car botap) (cdr botap)))))
 
 (defun eglot-code-actions (beg &optional end action-kind)
   "Offer to execute actions of ACTION-KIND between BEG and END.

[Andre0991]

This works as intended, yes. I tested with and without region 💯

[joaotavora]

OK I pushed this to master. I think it makes sense. Let's see if there aren't many complaints 😄

[Andre0991]

Perfect. Many thanks!

[Andre0991]

Resolved by 03fc783.
eglot considers the 'thing at point' now.

Thanks, João.