Rust and TOML setup

[ia0]

I'm sharing my experience setting up eglot with rust-analyzer (for Rust) and taplo (for TOML) in case it might help anyone trying to do the same (I wish I had this back then).

Minimal setup

This is straightforward from eglot documentation:

(add-hook 'rust-mode-hook 'eglot-ensure)
(add-hook 'conf-toml-mode-hook 'eglot-ensure)
(with-eval-after-load 'eglot
  (add-to-list 'eglot-server-programs
               '(conf-toml-mode . ("taplo" "lsp" "stdio"))))

You'll need to install rust-analyzer and taplo if you don't already have them:

rustup component add rust-analyzer
cargo install taplo-cli --features=lsp

Subjective setup

Rust-analyzer may consume a non-negligible amount of RAM depending on the project. If you work on multiple projects, I suggest customizing eglot-autoshutdown to t. This way, when closing the last buffer of a project, eglot will shutdown rust-analyzer, thus saving memory for other open projects where rust-analyzer is running.

If you use company:

(add-hook 'rust-mode-hook 'company-mode)

If you use flycheck, let me know if you find out how to use it. I had to fallback using flymake. I'm essentially using those keybindings:

(add-hook 'flymake-mode-hook
 (lambda ()
   ;; I used to have this go to the first error with flycheck, but only managed to go to the
   ;; next error with flymake. That's good enough for me.
   (define-key flymake-mode-map (kbd "C-c g")
     (lambda () (interactive) (flymake-goto-next-error 1 '(:error) t)))
   (define-key flymake-mode-map (kbd "C-c l") 'flymake-show-buffer-diagnostics)
   (define-key flymake-mode-map (kbd "C-c n") 'flymake-goto-next-error)
   (define-key flymake-mode-map (kbd "C-c p") 'flymake-goto-prev-error)
 )
)

I want eglot-format (in a TOML buffer) to match what taplo format does in the command line. I had to set the following up:

(add-hook 'conf-toml-mode-hook (lambda ()
  (setq tab-width 2) ;; otherwise 4
  (setq require-final-newline t))) ;; otherwise nil

I don't know how eglot would behave without the following project root definitions. So if you get issues because your project root is wrong, you may need this:

(add-hook 'project-find-functions 'ia0-project-find-root)
(defun ia0-project-find-root (dir)
  (let ((root (cond
    ((eq major-mode 'rust-mode) (locate-dominating-file dir "Cargo.toml"))
    ((eq major-mode 'conf-toml-mode) (or
      (locate-dominating-file dir "taplo.toml")
      (locate-dominating-file dir ".git"))))))
    (if root `(transient . ,root))))

And here's my eglot keybindings:

(add-hook 'eglot-managed-mode-hook
 (lambda ()
   (eglot-inlay-hints-mode 0)
   (define-key eglot-mode-map (kbd "C-c a") 'eglot-code-actions)
   (define-key eglot-mode-map (kbd "C-c c") 'ia0-eglot-edit-cargo) ;; see Experimental setup below
   (define-key eglot-mode-map (kbd "C-c C") (lambda () (interactive)
     (find-file (concat (project-root (project-current)) "Cargo.toml"))))
   (define-key eglot-mode-map (kbd "C-c f") 'eglot-format)
   (define-key eglot-mode-map (kbd "C-c h") 'eldoc)
   (define-key eglot-mode-map (kbd "C-c i") 'eglot-find-implementation)
   (define-key eglot-mode-map (kbd "C-c r") 'eglot-rename)
   (define-key eglot-mode-map (kbd "C-c t") 'eglot-find-typeDefinition)
   (define-key eglot-mode-map (kbd "C-c w d") 'eglot-list-connections)
   (define-key eglot-mode-map (kbd "C-c w r") 'eglot-reconnect)
   (define-key eglot-mode-map (kbd "C-c y") 'eglot-inlay-hints-mode)
 )
)

Once you have a working setup, you might want to disable eglot logging (improving performance):

(with-eval-after-load 'eglot (setq eglot-events-buffer-size 0))

Experimental setup

Rust-analyzer doesn't provide an easy way to change your view of the code. By view I mean things like target, features, etc. To solve this issue, I'm computing the initialization options dynamically when eglot invokes rust-analyzer. Eglot provides a very convenient way to do that in comparison to lsp-mode:

(with-eval-after-load 'eglot
  (add-to-list 'eglot-server-programs '(rust-mode .
    ("rust-analyzer" :initializationOptions ia0-eglot-config))))

The initialization options are computed based on the project root:

(defun ia0-eglot-config (server)
  `(:cargo (:features ,(ia0-eglot-get 'features)
            :noDefaultFeatures ,(ia0-eglot-bool 'noDefaultFeatures)
            :target ,(ia0-eglot-get 'target))
    :check (:allTargets ,(ia0-eglot-bool 'allTargets)
            :command ,(ia0-eglot-get 'command)
            :invocationStrategy "once") ; optional
    :diagnostics (:enable :json-false))) ; optional

The :diagnostics line is a bit extreme. You might not want it. I want it because I've had some false positives from rust-analyzer and don't trust it to produce correct diagnostics. So I'm only using diagnostics from the compiler. Note that even in this case, rust-analyzer introduces its own corruption to the compiler cache (see rust-lang/rust-analyzer#14722).

You may also not want the :invocationStrategy line. I'm also not sure I need it, but prefer that setting over per_workspace. I'm not sure what rust-analyzer documentation means by workspace, but I'm not using cargo workspaces (they create more problems than they solve) and have a one-to-one mapping between crates and rust-analyzer instance.

The initialization options values come from a hash map indexed by project roots. This mimics the directory local idea from emacs, but making it work dynamically instead of statically in files.

;; Default settings for a given project.
(setq ia0-eglot-default (make-hash-table))
(puthash 'command "check" ia0-eglot-default)
(puthash 'allTargets t ia0-eglot-default)
(puthash 'target nil ia0-eglot-default)
(puthash 'noDefaultFeatures nil ia0-eglot-default)
(puthash 'features [] ia0-eglot-default)
;; Maps from project root to project settings.
(setq ia0-eglot (make-hash-table :test 'equal))
(defun ia0-eglot-get (k)
  (let ((w (project-root (project-current))))
    (gethash k (gethash w ia0-eglot ia0-eglot-default))))
(defun ia0-eglot-put (k v)
  (let* ((w (project-root (project-current)))
         (h (gethash w ia0-eglot)))
    (unless h
      (setq h (copy-hash-table ia0-eglot-default))
      (puthash w h ia0-eglot))
    (puthash k v h)))
(defun ia0-eglot-bool (k) (if (ia0-eglot-get k) t :json-false))

And finally there must be a way to conveniently edit those settings. This is done with ia0-eglot-edit-cargo which I map to C-c c. This shows you the current settings in the form of a cargo invocation command in the minibuffer. You can edit it and confirm, which would restart the rust-analyzer instance with the updated settings. This is experimental and will not return errors. This only supports:

• Changing the cargo command (e.g. check, clippy, etc)
• Changing features with --features=foo or --features=bar,baz
• Disabling default features with --no-default-features
• Changing the target with --target=thumbv7em-none-eabi or --target=wasm32-unknown-unknown
• Checking all targets with --all-targets

(defun ia0-eglot-print-cargo ()
  "Returns the initialization options for rust-analyzer as a cargo command."
  (let* ((command (ia0-eglot-get 'command))
         (all-targets (ia0-eglot-get 'allTargets))
         (target (ia0-eglot-get 'target))
         (no-default (ia0-eglot-get 'noDefaultFeatures))
         (features (ia0-eglot-get 'features))
         (cargo (concat "cargo " command)))
    (when all-targets (setq cargo (concat cargo " --all-targets")))
    (when target (setq cargo (concat cargo " --target=" target)))
    (when no-default (setq cargo (concat cargo " --no-default-features")))
    (setq features (mapconcat 'identity features ","))
    (unless (string= features "")
      (setq cargo (concat cargo " --features=" features)))
    cargo))

(defun ia0-eglot-edit-cargo ()
  "Edit rust-analyzer initialization options to mimic cargo."
  (interactive)
  (let ((cargo (read-string "Analyze: " (ia0-eglot-print-cargo)))
        (args []))
    (setq cargo (split-string cargo " " t))
    (ia0-eglot-put 'command (nth 1 cargo))
    (setq cargo (mapcar (lambda (x) (split-string x "=")) (nthcdr 2 cargo)))
    (ia0-eglot-put 'allTargets (if (assoc "--all-targets" cargo) t))
    (let ((target (assoc "--target" cargo)))
      (if target (ia0-eglot-put 'target (cadr target))
        (ia0-eglot-put 'target nil)))
    (ia0-eglot-put 'noDefaultFeatures
      (if (assoc "--no-default-features" cargo) t))
    (let ((features (assoc "--features" cargo)))
      (if features (ia0-eglot-put 'features
                     (vconcat (split-string (cadr features) ",")))
        (ia0-eglot-put 'features [])))
    (eglot-reconnect (eglot-current-server))))