How to implement lsp extension using steel ?

[noor-tg]

Hi,

As per the FAQ. Lsp extensions will not be implemented in helix core.

I want to implement dart Lsp extension called closingLabels.

How to do it using steel ?

Helix discussion

[mattwparas]

So you'll want to use the send-lsp-command function:

From the docs:

Send an lsp command. The lsp-name must correspond to an active lsp.
The method name corresponds to the method name that you'd expect to see
with the lsp, and the params can be passed as a hash table. The callback
provided will be called with whatever result is returned from the LSP,
deserialized from json to a steel value.

Example

(define (view-crate-graph)
  (send-lsp-command "rust-analyzer"
                    "rust-analyzer/viewCrateGraph"
                    (hash "full" #f)
                    ;; Callback to run with the result
                    (lambda (result) (displayln result))))

Specifically for this, I don't know what the result will look like, but then it'll be the responsibility of the client to render those labels. In this case, you could try using the add-inlay-hint and remove-inlay-hint api to render the closing labels.

[noor-tg]

Thanks

[noor-tg]

so I searched the lsp docs and found this:
https://github.com/dart-lang/sdk/blob/master/pkg/analysis_server/tool/lsp_spec/README.md#darttextdocumentpublishclosinglabels-notification

closingLabels (bool?): When set to true, dart/textDocument/publishClosingLabels notifications will be sent with information to render editor closing labels.
Direction: Server -> Client Params: { uri: string, labels: { label: string, range: Range }[] }
Notifies the client when closing label information is available (or updated) for a file.

so how to listen to this event using steel?

[mattwparas]

So when you asked this question it wasn't possible, but I've just pushed some additions that let you subscribe to notifications from the lsp:

If you're willing to be on the bleeding edge a bit, you could help me experiment with this since I haven't had a chance to fully test it out. The docs:

Register a callback to be called on LSP notifications sent from the server -> client
that aren't currently handled by Helix as a built in.

(register-lsp-notification-handler lsp-name event-name handler)

• lsp-name : string?
• event-name : string?
• function : (-> hash? any?) ;; Function where the first argument is the parameters

Examples

(register-lsp-notification-handler "dart"
                                    "dart/textDocument/publishClosingLabels"
                                    (lambda (args) (displayln args)))

Note, displayln won't really do anything on its own without using some of my other extensions that intercept the prints and put them in to a window in the editor. If you want to just tail the logs from helix, you could do:

(log::info! (to-string args))

And see if thats coming through

[noor-tg]

So when you asked this question it wasn't possible, but I've just pushed some additions that let you subscribe to notifications from the lsp:

If you're willing to be on the bleeding edge a bit, you could help me experiment with this since I haven't had a chance to fully test it out. The docs:

Register a callback to be called on LSP notifications sent from the server -> client that aren't currently handled by Helix as a built in.

(register-lsp-notification-handler lsp-name event-name handler)

• lsp-name : string?
• event-name : string?
• function : (-> hash? any?) ;; Function where the first argument is the parameters

Examples

(register-lsp-notification-handler "dart"
                                    "dart/textDocument/publishClosingLabels"
                                    (lambda (args) (displayln args)))

Note, displayln won't really do anything on its own without using some of my other extensions that intercept the prints and put them in to a window in the editor. If you want to just tail the logs from helix, you could do:

(log::info! (to-string args))

And see if thats coming through

@mattwparas thank you very much

[noor-tg]

It is working. But log::info! Is not printing to the log file.

And the add-inlay-hint accepts the char index. While the returned data contains line number and char index in that line.
So to convert line + char to char index. I searched and found helix.character-info but it is not clear from the docs what it accept as param.

[mattwparas]

Just pushed a few more rope functions, need to update the docs to include them as well. Give this a shot:

(require "helix/editor.scm")
(require-builtin helix/core/text as text.)

;; @doc
;; Get the currently focused document as a rope
(define (focused-document->rope)
  (let* ([focus (editor-focus)]
         [focus-doc-id (editor->doc-id focus)])
    (editor->text focus-doc-id)))

;;@doc
;; Converts the currently focused document row and column
;; coordinates to a character offset
(define (current-document-row-col->offset row col)
  (define rope (focused-document->rope))
  (+ (text.rope-line->char rope row) col))

[mattwparas]

Okay, just added the rope docs, they're under the helix/core/text module in the steel-docs.md file.

[noor-tg]

thanks @mattwparas. now all the closing labels show in the first file (at least). I marked the question as complete because I can't spend more time on it. and this is the last version of my code about the dart lsp closing labels extension:

(require-builtin helix/core/text as text.)
(require "helix/misc.scm")
(require "helix/editor.scm")
(require "helix/configuration.scm")
(require "helix/ext.scm")
(require-builtin steel/time)

;; @doc
;; Get the currently focused document as a rope
(define (focused-document->rope)
  (let* ([focus (editor-focus)]
         [focus-doc-id (editor->doc-id focus)])
    (editor->text focus-doc-id)))

;;@doc
;; Converts the currently focused document row and column
;; coordinates to a character offset
(define (current-document-row-col->offset row col)
  (define rope (focused-document->rope))
  (+ (text.rope-line->char rope row) col))

;;@doc
;; label-info: hashmap label info
;; get end line, end char and label info
;; add some prefix
;; set to inlay
(define (set-label-to-inlay label_info)
  (define end_info (hash-get (hash-get label_info 'range) 'end))
  (define line (exact (hash-get end_info 'line)))
  (define char (exact (hash-get end_info 'character)))
  (define label (hash-get label_info 'label))
  (log::info! (to-string label_info))
  (add-inlay-hint (current-document-row-col->offset line (+ char 1)) (string-append " // " label)))

;;@doc
;; listen for dart lsp event for closingLabels
;; extract labels from the response
;; and run set-label-to-inlay in loop
(define (closing-labels)
  (register-lsp-notification-handler "dart"
                                     "dart/textDocument/publishClosingLabels"
                                     (lambda (args)
                                       (define labels (hash-get args 'labels))
                                       (map set-label-to-inlay (reverse labels)))))

(provide closing-labels)

thank you @mattwparas for answering all my questions. and adding the needed functionality.

[mattwparas]

thank you for working with me on this, appreciate it