Snippet expansion not enabled for sourcekit-lsp

[nhojb]

I have eglot setup with sourcekit-lsp for a Swift project. Generally it's working great.

However, I cannot get eglot to request snippet support from the server. I have yas-global-mode enabled in my emacs config and also use company. company-backends is set to the default value of (company-capf).

Here's the server initialisation output:

[internal] Fri Jul  1 11:34:28 2022:
(:message "Running language server: (/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/sourcekit-lsp)")
[client-request] (id:1) Fri Jul  1 11:34:28 2022:
(:jsonrpc "2.0" :id 1 :method "initialize" :params
          (:processId 41477 :rootPath "/Users/john/Projects/Raycast/RaycastApp/" :rootUri "file:///Users/john/Projects/Raycast/RaycastApp" :initializationOptions #s(hash-table size 1 test eql rehash-size 1.5 rehash-threshold 0.8125 data
                                                                                                                                                                                ())
                      :capabilities
                      (:workspace
                       (:applyEdit t :executeCommand
                                   (:dynamicRegistration :json-false)
                                   :workspaceEdit
                                   (:documentChanges t)
                                   :didChangeWatchedFiles
                                   (:dynamicRegistration t)
                                   :symbol
                                   (:dynamicRegistration :json-false)
                                   :configuration t :workspaceFolders t)
                       :textDocument
                       (:synchronization
                        (:dynamicRegistration :json-false :willSave t :willSaveWaitUntil t :didSave t)
                        :completion
                        (:dynamicRegistration :json-false :completionItem
                                              (:snippetSupport :json-false :deprecatedSupport t :tagSupport
                                                               (:valueSet
                                                                [1]))
                                              :contextSupport t)

As you can see :snippetSupport is :json-false. If I force this to t (in eglot.el) the server responds with snippet completions, however they are not expanded correctly when I complete them in Emacs.

Here are the relevant sections of my init.el. I'm slightly tearing my hair out over this - nothing I've tried seems to enable snippet expansion in eglot.

FWIW snippet expansion worked automatically in lsp-mode, but I much prefer eglot in general.

  (use-package company
    :custom
    (company-async-timeout 3)
    (company-selection-wrap-around t)
    :config
    ;; Use the tab-and-go frontend.
    ;; Allows TAB to select and complete at the same time.
    (company-tng-mode))

  (use-package company-dabbrev
    :after company
    :custom
    ;; Prevent dabbrev from downcasing completions:
    (company-dabbrev-downcase nil))

  (use-package company-prescient
    :after company
    :config
    (company-prescient-mode))

  (use-package company-emoji
    :after company
    :config
    (add-to-list 'company-backends 'company-emoji))

  (use-package company-yasnippet
    :after company)

  (use-package eaglet
    :custom
    (eglot-send-changes-idle-time 2.0)
    (eglot-autoshutdown t)
    (eglot-events-buffer-size 200000) ; 0 to disable
    (eglot-autoshutdown t)
    :config
    (add-to-list 'eglot-stay-out-of 'xref)
    (add-to-list 'eglot-server-programs '(swift-mode . ("/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/sourcekit-lsp"))))

  (use-package yasnippet
    :config
    (yas-global-mode 1)
    ;; Bind yas-expand to C-? (Cmd + Shift + /)
    ;; Unlike yas-maybe-expand, yas-expand works even if company popup is active.
    :bind (("C-?" . yas-expand)))

[nhojb]

Update: turns out the problem is company-tng-mode. If I disable this snippet completion magically works.

Any reason company-tng-mode is not supported by eglot?

[joaotavora]

Any reason company-tng-mode is not supported by eglot?

TL;DR: it doesn't make any sense for Eglot to support company-tng-mode. It's not Eglot's job. Eglot is just a bridge from LSP servers to Emacs's user-facing funcionality.

This kind of question happens often so I take some extra time to answer it as thoroughly as possible.

Eglot only aims supports things that are in Emacs. Company, i.e. company-mode, is a completion-displaying frontend that is not in Emacs, so Eglot doesn't directly support it. Company also comes with a family of other modes that feed it things to display. company-tng-mode would be one of them, I suppose.

Eglot is a completion-gatherer, but it doesn't feed these completions to Company directly. Rather, Eglot supports the completion-gathering protocol of Emacs called "capf" (completion at point functions). Eglot plays by this protocol's rules, gathering completions from the LSP server and delivers them to this framework. Thereafter, each completion-displaying framework can work with them as display them as they wish.

Turns out, fortunately for Company users, that Company has a fairly good rule-abiding adapter for this "capf" thing, called company-capf. It consumes Eglot-gathered through the capf interface and presents them to the user. The fact that it works fairly well, almos transparently (I use it all the time) is probably why people get the idea that Eglot "supports" Company. But it doesn't directly. It also supports a number of other completion displaying frontends.

The main point is that Eglot doesn't know about other company completion-gathering things such as company-tng-mode, company-foobarbaz-mode, etc. Nor should it, it has absolutely no relation to them.

You may see some :company-* things in Eglot's source code, but this still doesn't really mean Eglot "supports" Company directly. They are de-facto extensions of the "capf" protocol that were originally designed to be consumed by company-capf.

There is a final small lie in what I've told you. Because Company is so pervasive and popular, Eglot does have a bit of code that tweaks a couple of Company settings, most notably company-backends. You can neutralize this with eglot-stay-out-of, of course. The code in question turns OFF all Company backends except company-capf. Of course, this is done only in the buffers that Eglot is managing and only while it is managing them!

Why? Well, historically, Company backends other than company-capf gave users an inconsistent/conflicting LSP experience when these users were using Eglot, unless one knew exactly what one was doing, what one is gaining, and what one is losing. IOW if you are a Company power-user you might be able to combine LSP and tng, whatever that is. Like me, I suppose most users aren't power users.

Before I added the little hack above they were frequently mystified as why "Eglot doesn't work with specific parts of Company". And that's exactly what seems to have happened to you.

Back to your problem:

The funny thing here is that you don't seem to have a company-mode element in eglot-stay-out-of. So Eglot's "unmystification heuristic" isn't working for you. There's probably something more in your configuration that you're not showing or I don't understand.

Also note that I have very little clue as to what use-package actually does. It may come as a surprise to you, but use-package is also not in Emacs (last I checked). It's a opaque macro, it may be doing all kinds of things I don't know about. So you have to trim down your configuration to something simpler or find someone with use-package knowledge (not me).

Also, I don't know what eaglet is, but it's a cool name :-)

[nhojb]

Thanks for the detailed explanation 👍

I think it was just unfortunate that company-tng-mode (which uses tab rather than return for selecting completions) had this cascade effect of disabling snippet expansion in eglot. I spent quite a bit of time trying to debug the problem, originally thinking it was related to my yasnippet config. Otherwise eglot worked out of the box for me and I'm very happy with it.

Turns out I can enable pretty much the same behaviour for selecting company completions with this included in my company config:

:bind (:map company-active-map ("<tab>" . company-complete-selection))

Also, I don't know what eaglet is, but it's a cool name :-)

This is Safari being super aggressive about correcting eglot -> eaglet :-)